Mikrocontroller.net - Benutzerbeiträge [de]

Pollin Funk-AVR-Evaluationsboard

2014-04-15T10:18:08Z

145.225.60.4: Änderung 82652 von 159.224.160.42 (Diskussion) rückgängig gemacht.

== Motivation ==

Auf dieser Seite geht es um Erfahrungen eines Einsteigers mit dem Bausatz Funk-AVR-Evaluationsboard v1.1 von der Firma Pollin und um die C-Programmierung mithilfe des Boards und [[AVR-GCC]]/[[WinAVR]].

In den Beispielprogrammen wird nach Möglichkeit ein ATmega8 mit 12 MHz Quarz Taktquelle verwendet. Die Hardware auf dem Board ist sehr überschaubar (ein Taster, zwei LEDs, s. PDF unter Weblinks), so dass die Beispiele vielleicht zum eigenen Experimentieren anregen z. B. mit einem Steckbrettaufbau wie im [[AVR Tutorial]].

Bitte nutzt die Diskussionsseite oder das Forum, wenn beim Lesen Fragen, Anregungen oder Kritik auftauchen,

== Aufbau des Bausatzes ==

Alle Angaben hier beziehen sich auf die Version v1.1 des Bausatzes.

Mittlerweile (Stand 11/2008) verkauft Pollin die Version v1.2 und in dieser Version ist u.a. der Optokoppler nicht mehr vorhanden bzw. dessen Funktion übernehmen Jumper. Ebenso sind die anderen Leitungen von und zu den Funkmodulen über Jumper verbunden, d.h. man kann die Module elektrisch vom Board trennen (i.U. wichtig beim Fuse-Programmieren s.unten).

Praktisch ist bei dem Aufbau des Bausatzes nichts besonderes zu vermelden. Für einen Ungeübten (mich) hat der Aufbau ca. 2 h gedauert. Gegen Ende der Löterei liess meine Konzentration nach und ich musste ein paar unsaubere Lötstellen mit Entlötlitze nachbehandeln. Besser eine Pause machen.

Technisch/elektrisch siehe unter Weblinks der Erfahrungsbericht von Marco Schmoll (www.controller-designs.de).

Nach der genauen Betrachtung mit einer Lupe und keinen Auffälligkeiten wurde eine 9V Gleichspannung an die Klemme J5 angelegt. LED NETZ leuchtet. LED1 und LED2 sind aus. Mein Netzteil kann den Strom anzeigen. Folgende Werte wurden beobachtet:

* ca. 20 mA - AVR nicht eingesetzt, MAX232 nicht eingesetzt
* ca. 22 mA - AVR nicht eingesetzt, MAX232 nicht eingesetzt, RESET gedrückt
* ca. 25 mA - AVR nicht eingesetzt, MAX232 eingesetzt
* ca. 26 mA - AVR nicht eingesetzt, MAX232 eingesetzt, RESET gedrückt
* ca. 30 mA - '''ATmega8''' eingesetzt, MAX232 eingesetzt

Mein Board v1.1 hat ein '''Problem mit PD7 bei der 28-Pol Fassung''' (Atmega8 u.a.). Da fehlt - nachgemessen mit Durchgangsprüfer - eine Verbindung zur PD7 an der 40-Pol-Fassung und zu dem entsprechenden Pin an der 40-Pol Wannenbuchse. Die Verbindung PD7-40-Pol zu der 40-pol Wannenbuchse ist vorhanden. Möglicherweise wurde das schon vorher beobachtet: http://robotikportal.de/phpBB2/viewtopic.php?p=321115#321115

Wenn ein '''40-poliges IDE-Kabel''' in eigenen Schaltungen zum Verbinden mit J4 benutzt wird, vorher kontrollieren, ob im Kabel die benötigten Pins 1:1 verbunden/vorhanden sind (Danke an Markus [http://www.mikrocontroller.net/topic/167829#1604209], [http://www.mikrocontroller.net/topic/202999#1998317], [http://www.mikrocontroller.net/topic/207674#2053105])

== Einstellen der Taktquelle ==

Die folgenden Kommandozeilen zur Einstellung der Taktquelle in den [[AVR Fuses]] beziehen sich auf einen Windows PC und die ISP Programmiersoftware [[AVRDUDE]]. Kann nützlich sein, dafür kleine Batchdateien zu schreiben.

Wenn ein [[RFM12|Funkmodul]] installiert ist, kann es zu Problemen beim ISP-Programmieren kommen [http://www.mikrocontroller.net/topic/102101]. Dies kann sich auch beim '''Ändern''' der Fuses auswirken. Im schlimmsten Fall wird der AVR unbrauchbar. Vorher kontrollieren!

=== Serieller ISP auf dem Board ===

'''ATmega8 Fuses lesen'''

<pre>
@echo off
echo Serieller ISP auf dem Board
echo Lese ATmega8 Fuses
d:\winavr\bin\avrdude -v -p atmega8 -c ponyser -P com1
</pre>

Die Schnittstelle COM1 ist an die verwendete Schnittstelle auf dem PC anzupassen. Wichtig ist, dass kein zusätzlicher Parallelport-ISP angeschlossen ist. Wenn doch, wird der Atmega8 nicht erkannt!

'''ATmega8 1 MHz interner RC-Oszillator'''

<pre>
@echo off
echo Serieller ISP auf dem Board
echo Setze ATmega8 Fuses auf 1 MHz interner RC-Oszillator
d:\winavr\bin\avrdude -v -p atmega8 -c ponyser -P com1 -U lfuse:w:0xC1:m -U hfuse:w:0xD9:m
</pre>

'''ATmega8 12 MHz Quarz'''

Wenn das Board nach Anleitung aufgebaut wurde, d.h. in Q2 der 12,000 MHz Quarz eingesetzt wurde, kann man den ATmega8 auf max. 12 MHz einstellen:

<pre>
@echo off
echo Serieller ISP auf dem Board
echo Setze ATmega8 Fuses auf 12 MHz Quarz
d:\winavr\bin\avrdude -v -p atmega8 -c ponyser -P com1 -U lfuse:w:0x2F:m -U hfuse:w:0xD9:m
</pre>

=== Parallelport [[ISP]] Typ STK200 ===

'''ATmega8 Fuses lesen'''

<pre>
@echo off
echo Parallelport ISP Typ STK200
echo Lese ATmega8 Fuses
d:\winavr\bin\avrdude -v -p atmega8 -c stk200 -P lpt1
</pre>

[[Bild:Atmega8_Fuses_Werkseinstellung.png|thumb|right|256px|Werkseinstellung Fuses Atmega8 (Anzeige im AVR Fuse Calculator)]]

Die Schnittstelle LPT1 ist an die verwendete Schnittstelle auf dem PC anzupassen. Ebenso der Pfad zu dem Programm avrdude.exe.

Die ausgelesenen Fuses bei einem Fabrikneuen Atmega8 sollten dem Bild rechts entsprechen.

Siehe auch
* [http://palmavr.sourceforge.net/cgi-bin/fc.cgi AVR Fuse Calculator] von Mark Hämmerling. In den dortigen Default-Einstellungen ist der [[Watchdog]] aktiviert. Lässt man das so, funktioniert das Programm Blinky (s.u.) nicht wie erwartet: Nur LED2 zappelt, LED1 ist meist aus, weil vor dem Umschalten von LED1 der Watchdog den Atmega8 resettet, d.h. das Programm von neuem starten lässt.

'''ATmega8 1 MHz interner RC-Oszillator'''

<pre>
@echo off
echo Parallelport ISP Typ STK200
echo Setze ATmega8 Fuses auf 1 MHz interner RC-Oszillator
d:\winavr\bin\avrdude -v -p atmega8 -c stk200 -P lpt1 -U lfuse:w:0xC1:m -U hfuse:w:0xD9:m
</pre>

'''ATmega8 12 MHz Quarz'''

Wenn das Board nach Anleitung aufgebaut wurde, d.h. in Q2 der 12,000 MHz Quarz eingesetzt wurde, kann man den ATmega8 auf max. 12 MHz einstellen:

<pre>
@echo off
echo Parallelport ISP Typ STK200
echo Setze ATmega8 Fuses auf 12 MHz Quarz
d:\winavr\bin\avrdude -v -p atmega8 -c stk200 -P lpt1 -U lfuse:w:0x2F:m -U hfuse:w:0xD9:m
</pre>

== Programm ins Flash-ROM schreiben ==

Im folgenden wird angenommen, dass die zu programmierende Datei im iHEX-Format unter dem Namen atmega8.hex im aktuellen Verzeichnis befindet. Wenn ein Funkmodul installiert ist, kann es zu Problemen beim Flashen kommen [http://www.mikrocontroller.net/topic/102101].

=== Serieller ISP auf dem Board ===

<pre>
@echo off
echo Serieller ISP auf dem Board
echo Programmiere Atmega8 Flash-ROM mit Datei atmega8.hex
d:\winavr\bin\avrdude -p atmega8 -c ponyser -P com1 -e -U flash:w:atmega8.hex
</pre>

=== Parallelport ISP Typ STK200 ===

<pre>
@echo off
echo Parallelport ISP Typ STK200
echo Programmiere Atmega8 Flash-ROM mit Datei atmega8.hex
d:\winavr\bin\avrdude -p atmega8 -c stk200 -P lpt1 -e -U flash:w:atmega8.hex
</pre>

== Beispielprogramme ==

=== Blinky ===

Die beiden [[LED]] LED1 und LED2 auf dem Board sollen im 1s Takt wechselweise An und Aus gehen.

Die beiden On-board-LEDs sind ''active-high'' geschaltet, d.h. wenn am Pin des AVR ein logische 1 (HIGH Pegel) ausgegeben wird, leuchtet die LED. Wird eine logische 0 (LOW Pegel) ausgegeben, leuchtet die LED nicht. Das ist andersrum als im [[AVR-Tutorial: IO-Grundlagen#Hardware|AVR Tutorial]].

[[Bild:Atmega8_Taster_LEDs.png|Beschaltung des Tasters und der LEDs]]

<syntaxhighlight lang="c">
/*
Atmega8
Pollin Funk-AVR-Evaluationsboard v1.1

Project -> Configuration Options in AVR Studio:
Frequency: 1000000 bzw. 12000000
Optimization: -Os
*/
#include <avr/io.h>
#include <util/delay.h>

// LEDs sind active-high geschaltet
#define LED_AN(LED) (PORTD |= (1<<(LED)))
#define LED_AUS(LED) (PORTD &= ~(1<<(LED)))
#define LED_TOGGLE(LED) (PORTD ^= (1<<(LED)))
#define LED1 PD6
#define LED2 PD5
#define TASTER PB1

int main(void)
{
DDRB &= ~(1<<TASTER); // Port B: Eingang für Taster
DDRD |= (1<<LED1) | (1<<LED2); // Port D: Ausgang für LED1 und LED2

// Anfangseinstellung
LED_AN(LED1);
LED_AUS(LED2);

while(1)
{
_delay_ms(1000); // Wert 1000 erlaubt ab avr-libc 1.6
LED_TOGGLE(LED1);
LED_TOGGLE(LED2);
}
}
</syntaxhighlight>

=== Tasty ===

Wenn der On-board-Taster TASTER1 nicht gedrückt ist (Ruhezustand), soll die LED1 leuchten und LED2 soll nicht leuchten. Solange der User den Taster TASTER1 gedrückt hält, soll sich der Zustand der LEDs umkehren.

Der On-board-Taster TASTER1 ist ebenfalls ''active-high'' (siehe [[AVR-GCC-Tutorial#Tasten_und_Schalter|AVR-GCC-Tutorial]]) geschaltet, d.h. wenn der Taster geschlossen ist, liegt am Pin PB1 des AVR eine logische 1 (HIGH Pegel) an. Ist der Taster offen, liegt eine eine logische 0 (LOW Pegel) an. Das ist andersrum als im [[AVR-Tutorial: IO-Grundlagen#Hardware|AVR Tutorial]].

<syntaxhighlight lang="c">

/*
Atmega8
Externer Quarz-Oszillator: 12 MHz

Pollin Funk-AVR-Evaluationsboard v1.1
*/

#include <avr/io.h>
#include <util/delay.h>

// LEDs sind high-active geschaltet
#define LED_AN(LED) (PORTD |= (1<<(LED)))
#define LED_AUS(LED) (PORTD &= ~(1<<(LED)))
#define LED_TOGGLE(LED) (PORTD ^= (1<<(LED)))
#define LED1 PD6
#define LED2 PD5

// TASTER ist high-active geschaltet
#define TASTER PB1
#define TASTER_GEDRUECKT() (PINB & (1<<TASTER))

int main(void)
{
DDRB &= ~(1<<TASTER); // Port B: Eingang für Taster
DDRD |= (1<<LED1) | (1<<LED2); // Port D: Ausgang für LED1 und LED2

while(1)
{
if (!TASTER_GEDRUECKT())
{
// Taster ist nicht (!) gedrückt
LED_AN(LED1);
LED_AUS(LED2);
}
else
{
// Taster ist gedrückt
LED_AUS(LED1);
LED_AN(LED2);
}
}
}

</syntaxhighlight>

=== 2-Bit Zähler ===

Jeder Tastendruck auf TASTER1 soll eine Variable um Eins hochzählen. Der Inhalt der unteren beiden Bits der Zählvariable soll mit den beiden LEDs angezeigt werden.

Das Hochzählen darf nur erfolgen, wenn ein Wechsel von Offen nach Geschlossen stattfindet. Das Programm muss also berücksichtigen, ob ein Wechsel von "Taster offen" zu "Taster geschlossen" stattfindet und ob der Taster in einer Position gehalten wird.

Mit diesem Beispiel kann man grob feststellen, ob der TASTER1 auf dem Board zum Prellen neigt, d.h. wenn sich der Zählerstand nicht wie gewollt pro Tastendruck um Eins erhöht und ob deshalb eine spezielle Routine zur [[Entprellung]] erforderlich ist.

Mein Board zeigt bei diesem Programm keine Neigung zum Prellen. Die auf dem Board vorhandene [[Entprellung#Hardwareentprellung|Hardwareentprellung]] über einen [[Filter#Tiefpass|Tiefpassfilter]] mit C17 330 nF zwischen Taster und GND erfüllt hier ihren Zweck.

<syntaxhighlight lang="c">

/*
Atmega8
Externer Quarz-Oszillator: 12 MHz

Pollin Funk-AVR-Evaluationsboard v1.1
*/

#include <avr/io.h>
#include <util/delay.h>
#include <inttypes.h>

// LEDs sind high-active geschaltet
#define LED_AN(LED) (PORTD |= (1<<(LED)))
#define LED_AUS(LED) (PORTD &= ~(1<<(LED)))
#define LED_TOGGLE(LED) (PORTD ^= (1<<(LED)))
#define LED1 PD6
#define LED2 PD5

// TASTER ist high-active geschaltet
#define TASTER PB1
#define TASTER_GEDRUECKT() (PINB & (1<<TASTER))
#define TASTE_AUF 0
#define TASTE_ZU 1

void ausgabe(uint8_t wert)
{
if (wert & (1<<0)) // Bit 0
LED_AN(LED1);
else
LED_AUS(LED1);

if (wert & (1<<1)) // Bit 1
LED_AN(LED2);
else
LED_AUS(LED2);
}

int main(void)
{
uint8_t alter_tastenzustand = TASTE_AUF;
uint8_t zaehler = 0;

DDRB &= ~(1<<TASTER); // Port B: Eingang für Taster
DDRD |= (1<<LED1) | (1<<LED2); // Port D: Ausgang für LED1 und LED2

while(1)
{
ausgabe(zaehler);

if (TASTER_GEDRUECKT() && (alter_tastenzustand == TASTE_AUF))
{
// Wechsel von OFFEN nach GESCHLOSSEN
zaehler++;
alter_tastenzustand = TASTE_ZU;
}

if (!TASTER_GEDRUECKT())
alter_tastenzustand = TASTE_AUF;
}
}

</syntaxhighlight>

=== 8-Bit Zähler mit RS232-Anschluss ===

Das Beispiel 2-Bit Zähler soll jetzt ausgebaut werden. Im Detail soll der 8-Bit Zählerstand über [[RS232]] auf einen PC ausgegeben werden. Ausserdem soll "ferngesteuert" eine Veränderung des Zählerstands vom PC aus möglich sein.

Auf der PC-Seite wird die Kommunikation mit einem Terminalprogramm z. B. HyperTerm gemacht, so dass hier keine Programmierung notwendig ist. Lediglich die Einstellung der RS232-Schnittstelle (z. B. COM1, 9600/8/N/1) muss passen. Auf der Atmega8-Seite sind zunächst wenige Grundfunktionen für die RS232-Kommunikation zu schreiben.

Die AVR-Grundfunktionen für die RS232-Kommunikation sind eine Funktion für die Initialisierung der µC-eigenen UART-Schnittstelle (Bsp.: UART_init) und eine Funktion für das Senden eines Zeichens (Bsp.: UART_putchar) sowie je eine Funktion für das Warten auf ein Zeichens (Bsp.: UART_getchar) bzw. eine nicht-wartende Funktion um festzustellen, ob ein Zeichen des PCs an der UART-Schnittstelle des µC anliegt (Bsp. UART_peekchar).

Als Programmablauf wurde die UART-Kommunikation mit der technisch relativ einfachen Methode Polling eingerichtet, d.h. das Programm fragt selbst möglichst regelmässig und oft genug für einen sinnvolle Kommunikation die UART Schnittstelle ab, ob Zeichen empfangen wurden oder gesendet werden können. Hier erklärt sich auch der Zweck für die nicht-wartende Funktion UART_peekchar() - wenn kein Zeichen vom PC über RS232 anliegt, soll der µC mit dem bekannten Programmablauf weitermachen, damit die Taster-Eingaben ausgewertet werden. Die technisch meistens vorteilhaftere Alternative wäre die Interruptmethode, d.h. das Hauptprogramm wird automatisch genau dann unterbrochen, wenn ein Zeichen empfangen wurde oder gesendet werden kann und der µC verzweigt in spezielle Grundfunktionen, die sog. Interrupthandler, die sich um die Kommunikation kümmern. Nach dem Abarbeiten der Unterbrechung geht es dann im eigentlichen Hauptprogramm weiter. Ein UART_peekchar-Trick ist bei dieser Programmierweise nicht nötig. Die Programmierweise mit UART-Interrupts könnte Teil eines künftigen Beispiels sein.

Die Grundfunktionen werden von einer allgemeinen Funktion (Bsp.: rs232) verwendet, um den Zählerstand an den PC auszugeben bzw. um Eingaben auf dem PC in einen neuen Zählerstand umzusetzen. Da die Funktion rs232 den Zählerstand ändern soll, wird ihr die Adresse der Zählervariable (&zaehler) übergeben, d.h. es wird hier mit Zeigern (Pointern) gearbeitet.

Per RS232 können komfortabel mehr Informationen ausgegeben werden als über die beiden LEDs. Im Beispiel wird der Zählerstand in drei verschiedenen Zahlensystemen ausgegeben und es wird der Zustand der beiden LEDs übermittelt. Der Clou hinsichtlich Bedienung des Zählers ist, dass per RS232 auch komfortabel mehr Bedienmöglichkeiten eingerichtet werden können als mit dem einfachen Taster: Zusätzlich zum Hochzählen (Plus-Taste) kann z. B. runtergezählt werden (Minus-Taste) oder es kann direkt eine bis zu dreistellige Zahlenfolge eingegeben werden, die zum Setzen des Zählerstands verwendet wird.

Bei der Initialisierung der UART wurden die Einstellungen 9600 Baud, 8 Datenbits, Keine Parity (No Parity) und 1 Stopbit gewählt. 8/N/1 ist ein gängiger Wert für RS232. Bei der Auswahl der Baudrate muss darauf geachtet werden, dass mit der gegebenen Taktrate auf dem Board (hier 12 MHz) nicht jede denkbare RS232-Baudrate gleich gut geeignet ist. Das Register zur Einstellung der Baudrate im µC kann nur mit ganzen Zahlen gefüllt werden, die dann benutzt werden, um durch Teilen die Taktrate der UART aus dem Takt der CPU abzuleiten. Bei einer CPU Taktrate von 12 MHz ergeben folgende Soll-Baudraten (in Baud) die angegebenen Einstellungen des Baudratenregisters (UBRR) und die Ist-Baudraten sowie die Abweichungen zwischen Soll- und Ist-Baudrate in Prozent: Die Formeln zur Berechnung stehen im Atmega8 Datenblatt im Kapitel UART.

{| class="wikitable sortable" id="baudrate-12mhz"
|-
|Soll-Baudrate
|UBRR (bei U2X=0)
|Ist-Baudrate (bei U2X=0)
|Abweichung [%] (bei U2X=0)
|UBRR (bei U2X=1)
|Ist-Baudrate (bei U2X=1)
|Abweichung [%] (bei U2X=1)
|-
|300
|2499
|300
|0,0
| -
| -
| -
|-
|1200
|624
|1200
|0,0
|1249
|1200
|0,0
|-
|2400
|311
|2403
|0,1
|624
|2400
|0,0
|-
|4800
|155
|4807
|0,1
|311
|4807
|0,1
|-
|9600
|77
|9615
|0,2
|155
|9615
|0,2
|-
|14,4K
|51
|14423
|0,2
|103
|14423
|0,2
|-
|19,2K
|38
|19230
|0,2
|77
|19230
|0,2
|-
|28,8K
|25
|28846
|0,2
|51
|28846
|0,2
|-
|38,4K
|18
|37473
|2,8
|38
|38461
|0,2
|-
|57,6K
|12
|57692
|0,2
|25
|57692
|0,2
|-
|76,8K
|8
|83333
|8,5
|16
|78947
|2,8
|-
|115,2K
|5
|125000
|8,5
|12
|115384
|0,2
|-
|230,4K
|2
|250000
|8,5
|5
|250000
|8,5
|-
|250K
|2
|250000
|0,0
|5
|250000
|0,0
|-
|}

Bestimmte Baudraten können ohne Abweichung oder mit tolerierbar kleiner Abweichung (max. 0,2%) eingestellt werden, während andere Baudraten immer zu grosse Abweichungen für eine fehlerfreie Kommunikation ergeben. Man kann obige Tabelle (von denen es ähnliche im Datenblatt für andere Taktraten gibt) verwenden oder man kann die UBRR Einstellung im Programmcode berechnen lassen (s. Programmcode unten). Im AVR-GCC-Tutorial ist zusätzlich ganz komfortabel eine Berechnung der Abweichung und eine Warnung bei zu grossen Werten angegeben, so dass man seine Wunschbaudrate in Richtung geringe Abweichung optimieren kann. Im folgenden Code wurde die gängige Baudrate 9600 Baud eingestellt.

Eine letzte grössere Änderung gegenüber dem 2-Bit-Zähler fällt an der Stelle der Taster-Eingabe auf: Jetzt mit der genaueren RS232-Ausgabe wurden Prelleffekte als unregelmässige Sprünge im Zählerstand beobachtet. Deshalb wurde Programmcode für eine einfache Entprellung nach dem [[Entprellung#Warteschleifen-Verfahren|Warteschleifenverfahren]] hinzugefügt. Wenn das Makro ENTPRELLUNG mit 0 definiert ist, entfällt die Entprellung, d.h. das Programm reagiert wie beim 2-Bit Zähler auf den Taster. Um die Entprellung zu aktivieren, wird das Makro ENTPRELLUNG z. B. mit 10, 25 oder 30 definiert und neu kompiliert und geflasht. Die Zahl im Makro gibt eine Wartezeit an, nach der der Zustand des Tasters nochmal geprüft wird. Hier kann man etwas experimentieren, was ein geeigneter Wert wäre.

<syntaxhighlight lang="c">

/*
Pollin Funk-AVR-Evaluationsboard v1.1
Atmega8

Externer Quarz-Oszillator: 12 MHz
Optimierung: -Os

RS232-Einstellungen:
9600 Baud, 8 Bits, No Parity, 1 Stopbit
*/

#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>

// LEDs sind high-active geschaltet
#define LED_AN(LED) (PORTD |= (1<<(LED)))
#define LED_AUS(LED) (PORTD &= ~(1<<(LED)))
#define LED_TOGGLE(LED) (PORTD ^= (1<<(LED)))
#define LED1 PD6
#define LED2 PD5

// TASTER ist high-active geschaltet
#define TASTER PB1
#define TASTER_GEDRUECKT() (PINB & (1<<TASTER))
#define TASTE_AUF 0
#define TASTE_ZU 1
/* in Millisekunden */
#define ENTPRELLUNG 10

void UART_init(void)
{
// Baudrate setzen
// 9600 Baud bei F_CPU 12 MHz
// (Baudratenfehler = +0,2%)
UBRRH = (uint8_t) ((F_CPU / (16 * 9600L) - 1) >> 8);
UBRRL = (uint8_t) (F_CPU / (16 * 9600L) - 1);

// Empfangen, Senden erlauben
UCSRB = (1<<RXEN) | (1<<TXEN);

// Frame Format: 8 Bits, No Parity, 1 Stopbit
UCSRC = (1<<URSEL) | ((1<<UCSZ1) | (1<<UCSZ0)) | ((0<<UPM1) | (0<<UPM0)) | (0<<USBS);
}

// Auf Zeichen im UART Eingang prüfen
uint8_t UART_peekchar(void)
{
// sofort zurückkehren und Zustand melden
return UCSRA & (1<<RXC);
}

// Auf Zeichen im UART Eingang warten
uint8_t UART_getchar(void)
{
// Warte bis UART Eingang voll
while ( !(UCSRA & (1<<RXC)) )
;
return UDR;
}

// Zeichen in UART Ausgang geben
void UART_putchar(char z)
{
// Warte bis UART Ausgang frei
while ( !(UCSRA & (1<<UDRE)) )
;
UDR = z;
}

// Zeichenkette (String) in UART Ausgang geben
void UART_puts(char *s)
{
while ( *s )
{
UART_putchar(*s);
s++;
}
}

#define EINGABE_START 0
#define EINGABE_ABBRUCH EINGABE_START
#define EINGABE_MAX 3
#define FORMFEED '\014'

void rs232(uint8_t *wert)
{
static int16_t alter_wert = -1;
uint8_t anzahl_ziffern;
uint8_t zeichen;
char puffer[23];

// Eingabe über RS232

// Ohne Warten prüfen, ob Zeichen an UART vorhanden
if ( UART_peekchar() )
{
// Zeichen ist da.

// Aktuellen Wert ausgeben

// Neue Seite im Terminal anfordern.
// Bewirkt ein Löschen des Bildschirms

UART_putchar(FORMFEED);

// Einleitender Text, was im folgenden ausgegeben wird
UART_puts("Alter Z\204hler = "); // \204 ist ä in Oktalschreibweise

// Zahl in Ziffernfolge umwandeln. Hier zuerst in Dezimalziffern
itoa((int) *wert, puffer, 10);
UART_puts(puffer);

// Dann die gleiche Zahl in Hexadezimalziffern
UART_puts(" 0x");
itoa((int) *wert, puffer, 16);
UART_puts(puffer);

// Dann die gleiche Zahl in Binärziffern
UART_puts(" 0b");
itoa((int) *wert, puffer, 2);
UART_puts(puffer);

// Schliesslich noch der Zustand der LEDs auf dem Board senden
UART_puts( (*wert & 2) ? " LED2-An " : " LED2-Aus");
UART_puts( (*wert & 1) ? " LED1-An" : " LED1-Aus");

// Zeilenabschluss zur Formatierung der Anzeige
UART_puts("\r\n");

// Neuen Wert eingeben

// Initialisierung
UART_puts("Eingabe> ");
anzahl_ziffern = EINGABE_START;

// Eingabeschleife
do
{
// 1. bereits Zeichen am UART Eingang abholen
// in weiteren Schleifen auf neue Zeichen warten
zeichen = UART_getchar();

// Zeichen auswerten
if ( (zeichen == '-') && (anzahl_ziffern == EINGABE_START) )
{
// MINUS
UART_puts(" -1");
UART_puts("\r\n");
*wert -= 1;
break;
}
else if ( (zeichen == '+') && (anzahl_ziffern == EINGABE_START) )
{
// PLUS
UART_puts(" +1");
UART_puts("\r\n");
*wert += 1;
break;
}
else if ( (zeichen == '\n') || (zeichen == '\r') )
{
// ENTER oder RETURN: Abschluss der Eingabe
break;
}
else if ( (zeichen >= '0') && (zeichen <= '9') )
{
// Eingabe einer Ziffer
UART_putchar(zeichen); // Echo
puffer[anzahl_ziffern++] = zeichen;
puffer[anzahl_ziffern] = 0;
}
else
{
// Sonstiges Zeichen ist für uns illegal
anzahl_ziffern = EINGABE_ABBRUCH;
UART_puts(" Abbruch.");
UART_puts("\r\n");
break;
}
}
while ( anzahl_ziffern < EINGABE_MAX );

// Eingabe prüfen
if ( anzahl_ziffern != EINGABE_ABBRUCH )
{
// Ziffern in Zahl umwandeln
int i = atoi(puffer);

// z. B. erlaubter Wertebereich sei 0 bis 255
if ( (i >= 0) && (i < 256) )
{
UART_puts(" Ok.");
UART_puts("\r\n");
*wert = (uint8_t) i;
}
else
UART_puts(" Ung\201ltig.\r\n"); // \201 ist ü in Oktalschreibweise
}
}

// Ausgabe auf RS232 (s.oben)
// bei nur Änderung des Wertes gegenüber der letzten Ausgabe
//
// alter_wert wurde mit -1 initialisiert. Das ist ausserhalb
// des Wertebereichs von *wert, D.h. spätere Abfrage, ob
// (alter_wert != *wert) ist, ist beim ersten Durchlauf wie
// gewünscht wahr,
//
if (alter_wert != *wert)
{
alter_wert = *wert;
UART_puts("Z\204hler = ");
itoa((int) *wert, puffer, 10);
UART_puts(puffer);
UART_puts(" 0x");
itoa((int) *wert, puffer, 16);
UART_puts(puffer);
UART_puts(" 0b");
itoa((int) *wert, puffer, 2);
UART_puts(puffer);
UART_puts( (*wert & 2) ? " LED2-An " : " LED2-Aus");
UART_puts( (*wert & 1) ? " LED1-An" : " LED1-Aus");
UART_puts("\r\n");
}
}

void ausgabe_led(uint8_t wert)
{
if (wert & (1<<0)) // Bit 0
LED_AN(LED1);
else
LED_AUS(LED1);

if (wert & (1<<1)) // Bit 1
LED_AN(LED2);
else
LED_AUS(LED2);
}

int main(void)
{
uint8_t alter_tastenzustand = TASTE_AUF;
uint8_t zaehler = 0;

DDRB &= ~(1<<TASTER); // Port B: Eingang für Taster
DDRD |= (1<<LED1) | (1<<LED2); // Port D: Ausgang für LED1 und LED2

UART_init();
UART_putchar(FORMFEED);

while (1)
{
rs232(&zaehler);

ausgabe_led(zaehler);

if ( TASTER_GEDRUECKT() )
{
#if ENTPRELLUNG
_delay_ms(ENTPRELLUNG);
if ( TASTER_GEDRUECKT() )
#endif /* ENTPRELLUNG */
{
// Wechsel von OFFEN nach GESCHLOSSEN?
if ( alter_tastenzustand == TASTE_AUF )
{
zaehler++;
alter_tastenzustand = TASTE_ZU;
}
}
}

if ( !TASTER_GEDRUECKT() )
{
#if ENTPRELLUNG
_delay_ms(ENTPRELLUNG);
if ( !TASTER_GEDRUECKT() )
#endif /* ENTPRELLUNG */
alter_tastenzustand = TASTE_AUF;
}
}
}

</syntaxhighlight>

=== Zähler mit LCD-Anzeige ===

Als nächstes soll noch eine [[LCD]]-Anzeige installiert werden.

In meiner Bastelkiste lag noch ein Text-LCD mit dem LCD-Controller [[HD44780]]. Erfreulicherweise gibt es für diesen LCD-Controller jede Menge fertigen Beispielcode zur Ansteuerung im Internet u.a. im [[AVR-GCC-Tutorial#LCD-Ansteuerung|AVR-GCC-Tutorial]].

Um den Beispielcode in der Form einzubinden, wie er im Tutorial zu finden ist und um das mittlerweise angewachsene Projekt übersichtlicher zu machen, werden zusammenhängende Codeteile in Unterdateien ausgelagert. Im folgenden Bild ist zu sehen, wie die einzelnen Dateien heissen und wie sie im AVR Studio eingebunden werden.

[[Bild:PFA_Projekt_ZLCD.png]]

Die Datei '''zaehler_lcd.c''' enthält die main-Funktion und die neue Ausgabefunktion ausgabe_lcd und die bereits bekannte Funktion ausgabe_led:

<syntaxhighlight lang="c">

/*
Pollin Funk-AVR-Evaluationsboard v1.1
Atmega8

Externer Quarz-Oszillator: 12 MHz
Optimierung: -Os

RS232-Einstellungen:
9600 Baud, 8 Bits, No Parity, 1 Stopbit
*/
#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>

#include "funkhw.h"
#include "rs232.h"
#include "lcd_routines.h"

/* in Millisekunden */
#define ENTPRELLUNG 10

void ausgabe_lcd(uint8_t wert)
{
static int16_t alter_wert = -1;
char puffer[23];

if (wert != alter_wert)
{
// Ausgabe nur bei Änderungen
alter_wert = wert;
itoa((int) wert, puffer, 10);

lcd_clear();
lcd_string("Zaehler = ");
lcd_string(puffer);
}
}

void ausgabe_led(uint8_t wert)
{
if (wert & (1<<0)) // Bit 0
LED_AN(LED1);
else
LED_AUS(LED1);

if (wert & (1<<1)) // Bit 1
LED_AN(LED2);
else
LED_AUS(LED2);
}

int main(void)
{
uint8_t alter_tastenzustand = TASTE_AUF;
uint8_t zaehler = 0;

DDRB &= ~(1<<TASTER); // Port B: Eingang für Taster
DDRD |= (1<<LED1) | (1<<LED2); // Port D: Ausgang für LED1 und LED2

UART_init();
UART_putchar(FORMFEED);

lcd_init();

while (1)
{
rs232(&zaehler); // RS232 Eingabe und Ausgabe

ausgabe_lcd(zaehler); // LCD Ausgabe

ausgabe_led(zaehler); // LED Ausgabe

if ( TASTER_GEDRUECKT() )
{
#if ENTPRELLUNG
_delay_ms(ENTPRELLUNG);
if ( TASTER_GEDRUECKT() )
#endif /* ENTPRELLUNG */
{
// Wechsel von OFFEN nach GESCHLOSSEN?
if ( alter_tastenzustand == TASTE_AUF )
{
zaehler++;
alter_tastenzustand = TASTE_ZU;
}
}
}

if ( !TASTER_GEDRUECKT() )
{
#if ENTPRELLUNG
_delay_ms(ENTPRELLUNG);
if ( !TASTER_GEDRUECKT() )
#endif /* ENTPRELLUNG */
alter_tastenzustand = TASTE_AUF;
}
}
}

</syntaxhighlight>

Die Datei '''lcd_routines.c''' enthält die Grundfunktionen für die LCD-Ansteuerung aus dem AVR-GCC-Tutorial.

In der Funktion lcd_enable musste das Timing leicht angepasst werden, weil bei meinem Display mit der 1 µs Pause Störungen aufgetreten waren.

<syntaxhighlight lang="c">

// Ansteuerung eines HD44780 kompatiblen LCD im 4-Bit-Interfacemodus
// http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
//
// Die Pinbelegung ist über defines in lcd-routines.h einstellbar

#include <avr/io.h>
#include "lcd_routines.h"
#include <util/delay.h>

// sendet ein Datenbyte an das LCD

void lcd_data(unsigned char temp1)
{
unsigned char temp2 = temp1;

LCD_PORT |= (1<<LCD_RS); // RS auf 1 setzen

temp1 = temp1 >> 4;
temp1 = temp1 & 0x0F;
LCD_PORT &= 0xF0;
LCD_PORT |= temp1; // setzen
lcd_enable();

temp2 = temp2 & 0x0F;
LCD_PORT &= 0xF0;
LCD_PORT |= temp2; // setzen
lcd_enable();

_delay_us(42);
}

// sendet einen Befehl an das LCD

void lcd_command(unsigned char temp1)
{
unsigned char temp2 = temp1;

LCD_PORT &= ~(1<<LCD_RS); // RS auf 0 setzen

temp1 = temp1 >> 4; // oberes Nibble holen
temp1 = temp1 & 0x0F; // maskieren
LCD_PORT &= 0xF0;
LCD_PORT |= temp1; // setzen
lcd_enable();

temp2 = temp2 & 0x0F; // unteres Nibble holen und maskieren
LCD_PORT &= 0xF0;
LCD_PORT |= temp2; // setzen
lcd_enable();

_delay_us(42);
}

// erzeugt den Enable-Puls
void lcd_enable(void)
{
// Bei Problemen ggf. Pause gemäß Datenblatt des LCD Controllers einfügen
// http://www.mikrocontroller.net/topic/81974#685882
LCD_PORT |= (1<<LCD_EN);
#if 1
_delay_us(4); // kurze Pause, Original aus dem Tutorial ist bei meinem Display zu kurz!
#else
_delay_us(1); // kurze Pause
#endif
// Bei Problemen ggf. Pause gemäß Datenblatt des LCD Controllers verlängern
// http://www.mikrocontroller.net/topic/80900
LCD_PORT &= ~(1<<LCD_EN);
}

// Initialisierung:
// Muss ganz am Anfang des Programms aufgerufen werden.

void lcd_init(void)
{
LCD_DDR = LCD_DDR | 0x0F | (1<<LCD_RS) | (1<<LCD_EN); // Port auf Ausgang schalten

// muss 3mal hintereinander gesendet werden zur Initialisierung

_delay_ms(15);
LCD_PORT &= 0xF0;
LCD_PORT |= 0x03;
LCD_PORT &= ~(1<<LCD_RS); // RS auf 0
lcd_enable();

_delay_ms(5);
lcd_enable();

_delay_ms(1);
lcd_enable();
_delay_ms(1);

// 4 Bit Modus aktivieren
LCD_PORT &= 0xF0;
LCD_PORT |= 0x02;
lcd_enable();
_delay_ms(1);

// 4Bit / 2 Zeilen / 5x7
lcd_command(0x28);

// Display ein / Cursor aus / kein Blinken
lcd_command(0x0C);

// inkrement / kein Scrollen
lcd_command(0x06);

lcd_clear();
}

// Sendet den Befehl zur Löschung des Displays

void lcd_clear(void)
{
lcd_command(CLEAR_DISPLAY);
_delay_ms(5);
}

// Sendet den Befehl: Cursor Home

void lcd_home(void)
{
lcd_command(CURSOR_HOME);
_delay_ms(5);
}

// setzt den Cursor in Zeile y (1..4) Spalte x (0..15)

void set_cursor(uint8_t x, uint8_t y)
{
uint8_t tmp;

switch (y)
{
case 1:
tmp=0x80+0x00+x;
break; // 1. Zeile
case 2:
tmp=0x80+0x40+x;
break; // 2. Zeile
case 3:
tmp=0x80+0x10+x;
break; // 3. Zeile
case 4:
tmp=0x80+0x50+x;
break; // 4. Zeile
}
lcd_command(tmp);
}

// Schreibt einen String auf das LCD

void lcd_string(char *data)
{
while (*data)
{
lcd_data(*data);
data++;
}
}

</syntaxhighlight>

Die Includedatei '''lcd_routines.h''' enthält die Leitungszuordnung für die LCD-Ansteuerung und die Prototypen für die LCD Funktionen.

Hier wurden die Signalleitungen von PORTD auf PORTC geändert. Und die Definition von F_CPU wurde mit #if/#endif auskommentiert, weil dieser Wert bereits mit den ''Projekt Configuration Options'' im AVR Studio auf 12 MHz gesetzt ist.

<syntaxhighlight lang="c">

// Ansteuerung eines HD44780 kompatiblen LCD im 4-Bit-Interfacemodus
// http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
//
void lcd_data(unsigned char temp1);
void lcd_string(char *data);
void lcd_command(unsigned char temp1);
void lcd_enable(void);
void lcd_init(void);
void lcd_home(void);
void lcd_clear(void);
void set_cursor(uint8_t x, uint8_t y);

#if 0
// Hier die verwendete Taktfrequenz in Hz eintragen, wichtig!
#define F_CPU 8000000
#endif

// LCD Befehle

#define CLEAR_DISPLAY 0x01
#define CURSOR_HOME 0x02

// Pinbelegung für das LCD, an verwendete Pins anpassen

#if 1
// Änderung des LCD Anschlusses
// Pollin Funk AVR Evaluationsboard v1.1
// DB4 bis DB7 des LCD sind mit PC0 bis PC3 des AVR verbunden
#define LCD_PORT PORTC
#define LCD_DDR DDRC
#define LCD_EN PC5
#define LCD_RS PC4
#define LCD_DB7 PC3
#define LCD_DB6 PC2
#define LCD_DB5 PC1
#define LCD_DB4 PC0
#else
#define LCD_PORT PORTD
#define LCD_DDR DDRD
#define LCD_RS PD4
#define LCD_EN PD5
// DB4 bis DB7 des LCD sind mit PD0 bis PD3 des AVR verbunden
#endif

</syntaxhighlight>

Die Includedatei '''funkhw.h''' enthält die gemeinsamen, boardspezifischen Port-Definitionen, die in mehreren Unterdateien benötigt werden:

<syntaxhighlight lang="c">

/*
Pollin Funk-AVR-Evaluationsboard v1.1
Atmega8
*/

// LEDs sind high-active geschaltet
#define LED_AN(LED) (PORTD |= (1<<(LED)))
#define LED_AUS(LED) (PORTD &= ~(1<<(LED)))
#define LED_TOGGLE(LED) (PORTD ^= (1<<(LED)))
#define LED1 PD6
#define LED2 PD5

// TASTER ist high-active geschaltet
#define TASTER PB1
#define TASTER_GEDRUECKT() (PINB & (1<<TASTER))
#define TASTE_AUF 0
#define TASTE_ZU 1

</syntaxhighlight>

Die Includedatei '''rs232.h''' enthält die Prototypen für die Funktionen in rs232.c:

<syntaxhighlight lang="c">

#ifndef FORMFEED
#define FORMFEED '\014'
#endif

void UART_init(void);

// Auf Zeichen im UART Eingang prüfen
uint8_t UART_peekchar(void);

// Auf Zeichen im UART Eingang warten
uint8_t UART_getchar(void);

// Zeichen in UART Ausgang geben
void UART_putchar(char z);

// Zeichenkette (String) in UART Ausgang geben
void UART_puts(char *s);

void rs232(uint8_t *wert);

</syntaxhighlight>

Und zum Schluss noch die Datei '''rs232.c''' mit den ungeänderten UART-Grundfunktionen und der rs232-Funktion.

<syntaxhighlight lang="c">

/*
Pollin Funk-AVR-Evaluationsboard v1.1
Atmega8

Externer Quarz-Oszillator: 12 MHz
Optimierung: -Os

RS232-Einstellungen:
9600 Baud, 8 Bits, No Parity, 1 Stopbit
*/
#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>

#include "funkhw.h"
#include "rs232.h"

#define EINGABE_START 0
#define EINGABE_ABBRUCH EINGABE_START
#define EINGABE_MAX 3

void UART_init(void)
{
// Bausrate setzen
// 9600 Baud bei F_CPU 12 MHz
// (Baudratenfehler = +0,2%)
UBRRH = (uint8_t) ((F_CPU / (16 * 9600L) - 1) >> 8);
UBRRL = (uint8_t) (F_CPU / (16 * 9600L) - 1);

// Empfangen, Senden erlauben
UCSRB = (1<<RXEN) | (1<<TXEN);

// Frame Format: 8 Bits, No Parity, 1 Stopbit
UCSRC = (1<<URSEL) | ((1<<UCSZ1) | (1<<UCSZ0)) | ((0<<UPM1) | (0<<UPM0)) | (0<<USBS);
}

// Auf Zeichen im UART Eingang prüfen
uint8_t UART_peekchar(void)
{
// sofort zurückkehren und Zustand melden
return UCSRA & (1<<RXC);
}

// Auf Zeichen im UART Eingang warten
uint8_t UART_getchar(void)
{
// Warte bis UART Eingang voll
while ( !(UCSRA & (1<<RXC)) )
;
return UDR;
}

// Zeichen in UART Ausgang geben
void UART_putchar(char z)
{
// Warte bis UART Ausgang frei
while ( !(UCSRA & (1<<UDRE)) )
;
UDR = z;
}

// Zeichenkette (String) in UART Ausgang geben
void UART_puts(char *s)
{
while ( *s )
{
UART_putchar(*s);
s++;
}
}

void rs232(uint8_t *wert)
{
static int16_t alter_wert = -1;
uint8_t anzahl_ziffern;
uint8_t zeichen;
char puffer[23];

// Eingabe über RS232

// Ohne Warten prüfen, ob Zeichen an UART vorhanden
if ( UART_peekchar() )
{
// Zeichen ist da.

// Aktuellen Wert ausgeben

// Neue Seite im Terminal anfordern.
// Bewirkt ein Löschen des Bildschirms

UART_putchar(FORMFEED);

// Einleitender Text, was im folgenden ausgegeben wird
UART_puts("Alter Z\204hler = "); // \204 ist ä in Oktalschreibweise

// Zahl in Ziffernfolge umwandeln. Hier zuerst in Dezimalziffern
itoa((int) *wert, puffer, 10);
UART_puts(puffer);

// Dann die gleiche Zahl in Hexadezimalziffern
UART_puts(" 0x");
itoa((int) *wert, puffer, 16);
UART_puts(puffer);

// Dann die gleiche Zahl in Binärziffern
UART_puts(" 0b");
itoa((int) *wert, puffer, 2);
UART_puts(puffer);

// Schliesslich noch der Zustand der LEDs auf dem Board senden
UART_puts( (*wert & 2) ? " LED2-An " : " LED2-Aus");
UART_puts( (*wert & 1) ? " LED1-An" : " LED1-Aus");

// Zeilenabschluss zur Formatierung der Anzeige
UART_puts("\r\n");

// Neuen Wert eingeben

// Initialisierung
UART_puts("Eingabe> ");
anzahl_ziffern = EINGABE_START;

// Eingabeschleife
do
{
// 1. bereits Zeichen am UART Eingang abholen
// in weiteren Schleifen auf neue Zeichen warten
zeichen = UART_getchar();

// Zeichen auswerten
if ( (zeichen == '-') && (anzahl_ziffern == EINGABE_START) )
{
// MINUS
UART_puts(" -1");
UART_puts("\r\n");
*wert -= 1;
break;
}
else if ( (zeichen == '+') && (anzahl_ziffern == EINGABE_START) )
{
// PLUS
UART_puts(" +1");
UART_puts("\r\n");
*wert += 1;
break;
}
else if ( (zeichen == '\n') || (zeichen == '\r') )
{
// ENTER oder RETURN: Abschluss der Eingabe
break;
}
else if ( (zeichen >= '0') && (zeichen <= '9') )
{
// Eingabe einer Ziffer
UART_putchar(zeichen); // Echo
puffer[anzahl_ziffern++] = zeichen;
puffer[anzahl_ziffern] = 0;
}
else
{
// Sonstiges Zeichen ist für uns illegal
anzahl_ziffern = EINGABE_ABBRUCH;
UART_puts(" Abbruch.");
UART_puts("\r\n");
break;
}
}
while ( anzahl_ziffern < EINGABE_MAX );

// Eingabe prüfen
if ( anzahl_ziffern != EINGABE_ABBRUCH )
{
// Ziffern in Zahl umwandeln
int i = atoi(puffer);

// z. B. erlaubter Wertebereich sei 0 bis 255
if ( (i >= 0) && (i < 256) )
{
UART_puts(" Ok.");
UART_puts("\r\n");
*wert = (uint8_t) i;
}
else
UART_puts(" Ung\201ltig.\r\n"); // \201 ist ü in Oktalschreibweise
}
}

// Ausgabe auf RS232 (s.oben)
// bei nur Änderung des Wertes gegenüber der letzten Ausgabe
//
// alter_wert wurde mit -1 initialisiert. Das ist ausserhalb
// des Wertebereichs von *wert, D.h. spätere Abfrage, ob
// (alter_wert != *wert) ist, ist beim ersten Durchlauf wie
// gewünscht wahr,
//
if (alter_wert != *wert)
{
alter_wert = *wert;
UART_puts("Z\204hler = ");
itoa((int) *wert, puffer, 10);
UART_puts(puffer);
UART_puts(" 0x");
itoa((int) *wert, puffer, 16);
UART_puts(puffer);
UART_puts(" 0b");
itoa((int) *wert, puffer, 2);
UART_puts(puffer);
UART_puts( (*wert & 2) ? " LED2-An " : " LED2-Aus");
UART_puts( (*wert & 1) ? " LED1-An" : " LED1-Aus");
UART_puts("\r\n");
}
}

</syntaxhighlight>

=== Uhr ===

Nachdem die Eingabe- und Ausgaberoutinen vorhanden sind, sollen jetzt die weiteren Innereien des ATmega8 erkundet werden. Als erstes kommt der Timer und damit die erste Interrupt-Programmierung an die Reihe. Und was liegt bei dem Thema näher, als eine Uhr zu programmieren...

Zunächst der Aufbau des Projektes:

* PFA_uhr.c - Das Hauptprogramm
* PFA_funkhw.h - Definitionen für das PFA ;-) Board
* PFA_rs232.c - Erweiterte rs232-Funktionen
* PFA_rs232.h - Prototypen zu den rs232-Funktionen
* PFA_uart.c - UART Grundfunktionen (aus ehemaligem rs232.c herausgezogen)
* PFA_uart.h - Prototypen zu den UART Grundfunktionen
* lcd-routines.c - Unverändert s.o.
* lcd-routines.h - Unverändert s.o.

'''PFA_uhr.c''' - Das Hauptprogramm

Drei Funktionen werden für die Uhr benötigt. Selbstverständlich eine Funktion zum Anzeigen der Uhrzeit auf dem LCD (Bsp.: uhrzeit_lcd). Und eine Funktion zum Starten der Uhr (Bsp.: uhr_init).

Sowie eine TickTack-Funktion, die regelmässig die Uhrzeit erhöht und zwar egal was das Programm sonst macht (Tasteneingabe, RS232 Ausgabe...)! Diese letzte Funktion heisst ISR(TIMER0_OVF_vect) und ist eine sog. Interrupt Service Routine für den TIMER0 OVerFlow Interrupt. Die Namen solcher ISR Funktionen sind nicht frei wählbar, sondern den einzelnen Interrupts fest zugeordnet. Wie die ISRs heissen, kann man in der Dokumentation zum jeweiligen AVR nachlesen.

Die Auswahl von TIMER0 ist willkürlich. Der ATmega8 hat insgesamt drei Timer, die unterschiedliche Fähigkeiten haben. TIMER0 ist davon der mit der geringsten Ausstattung, aber selbst die ist noch ausreichend, um damit eine Uhr zu programmieren. So können die anderen Timer für anderes freigehalten werden.

TIMER0 ist ein 8-Bit Timer, d.h. er kann so einstellt werden, dass er ab einem Startwert TCNT0 jedesmal um eins hochzählt, wenn er von seiner Taktquelle angetrieben wird. Die Taktquelle für den TIMER0 kann die Taktquelle des AVR sein oder ein durch den sog. Vorteiler (Prescaler) von 8, 64, 256 oder 1024 geteilte CPU-Takt. Welcher Vorteiler verwendet werden soll, wird im Register TCCR0 eingestellt.

Wenn der Endwert 255 (8-Bit!) überschritten wird und die Hochzählerei wieder bei 0 beginnt, kann eine Überlaufunterbrechung (Overflow Interrupt) ausgelöst werden, wenn das vom Programm aus im Register TIMSK so eingerichtet wurde.

Damit beim ersten Einschalten des Timers nicht sofort ein Interrupt ausgelöst wird, löscht man meistens vor dem Einschalten das betreffende sog. Interruptflag (hier im Register TIFR). Das Interruptflag ist innerhalb der CPU dafür entscheidend, ob beim nächsten abzuarbeitenden Maschinenbefehl das Hauptprogramm ausgeführt wird oder ob in die ISR verzweigt wird.

Das Einschalten selbst ist ein zweistufiger Prozess: zunächst stellt man in dem Register TIMSK ein, welchen Interrupt man erlauben will. Anschliessend werden mit der Funktion '''sei''', alle (d.h. global) erlaubten Interrupts auch von der CPU abgeprüft. Die Gegenfunktion zu sei, d.h. Interrupts global sperren wäre die Funktion '''cli''', aber die wird in diesem Beispiel nicht benötigt.

Jetzt geht's ans Rechnen, wie der TIMER0 genau eingestellt werden muss, damit man damit auch eine Uhr programmieren kann.

In der folgenden Tabelle ist abhängig vom Prescaler P (Spalte 1) berechnet, welchen Takt T man erhält, wenn die F_CPU 12 MHz beträgt (zweite Spalte). In der dritten Spalte D1 ist berechnet, wie lange es dauert, wenn der Timer um eins hochzählt. Bzw. in der vierten Spalte bei D2, wenn nach 256 Zählschritten (0 bis 255 dann +1 gibt Überlauf zu 0) der Overflow Interrupt auftritt. In der fünften Spalte N256 ist berechnet, wieviele Overflow-Interrupts man mitzählen müsste, um auf 1 Sekunde zu kommen.

{| class="wikitable sortable" id="timer0-12mhz-1"
|-
|P = Prescaler
|T = Taktrate [Hz]
|1.000.000/(T/P) = D1 = Dauer für +1 [µs]
|(1.000/(T/P))*256 = D2 = Dauer bis Overflow [ms]
|1000/((1.000/(T/P))*256) = N256 = Anzahl Overflows für 1 s
|-
|1
|12.000.000
|0,083
|0,021
|46875
|-
|8
|1.500.000
|0,667
|0,171
|5859,38
|-
|64
|187.500
|5,333
|0,171
|732,42
|-
|256
|46.875
|21,333
|8,333
|183,11
|-
|1024
|11.718,75
|85,333
|21,845
|45,78
|-
|}

In diesem Fall wird nur beim Prescaler 1 eine ganze Zahl von Overflow-Interrupts durchlaufen, so dass man nach einer ganzen Zahl von Zählschritten glatt auf 1 Sekunde kommt. Aber wenn man mit diesem Prescaler 1 arbeitet, treten die Interrupts zigtausend Mal auf, so dass das Programm nur noch am sehr schnellen Hochzählen und Aufrufen des Interrupts ist... das ist keine Lösung.

Aber es gibt zwei Auswege für die anderen Prescaler-Werte. Denn man kann ja vorgeben, ab welchem Startwert in Richtung 255 hochgezählt wird und damit kann man festlegen, wieviele Schritte bis zum Overflow vergehen. Vielleicht kann man die Anzahl so geschickt wählen, dass eine ganze Zahl von Overflow Interrupts glatt 1 Sekunde ergibt? Gesucht ist also eine Zahl X, bei der gilt, dass N1/X eine ganze Zahl ergibt. Klar X=1 ist fast immer eine Lösung, nur werden die Zahlen und damit der Zeitverbrauch in der Interruptroutine gigantisch...

{| class="wikitable sortable" id="timer0-12mhz-2"
|-
|P = Prescaler
|T/P = N1 = Anzahl +1 Schritte für 1 s
|-
|1
|12.000.000
|-
|8
|1.500.000
|-
|64
|187.500
|-
|256
|46.875
|-
|1024
|11.718,75
|-
|}

Spielt man es für die interessanten niedrigen Taktraten durch, kann man beim Prescaler 1024 leider keine Zahl X finden, bei der 11.718,75/X ganzzahlig ist. Aber beim Prescaler 256 gibt es mehrere Lösungen:

{| class="wikitable sortable" id="timer0-12mhz-3"
|-
|X
|46875/X =
|-
|1
|46875
|-
|3
|15625
|-
|5
|9375
|-
|15
|3125
|-
|25
|1875
|-
|75
|625
|-
|125
|375
|-
|}

Wählt man also den Startwert so, dass der TIMER0 125 mal hochzählen muss, bis ein Overflow auftritt, hat man nach 375 Overflows genau eine Sekunde lang abgezählt. Um das Einzurichten muss also der TCNT0 Startwert nicht auf 0 (= 256 = 256-0 Schritte bis Overflow) gesetzt werden, sondern auf 256-125 (= -125 bei 8-Bit Rechnung, da dann 256 = 0 gilt). Und der Startwert muss bei jedem Overflow Interrupt wieder auf den berechneten Startwert gesetzt werden. Das kann man durch geschickte Wahl der Timer-Einstellung automatisch machen lassen und erhält das genauste Verfahren.

Aber es gibt noch eine andere (möglicherweise ungenauere) Lösung und die wird im folgenden Programm benutzt:

Man macht so viele 256 Schritt-Overflows, wie es geht, ohne die Sekunde zu überschreiten und für den letzten Rest verringert man die Anzahl der Schritte bis zum Overflow.

Beim Prescaler 256 und F_CPU 12 MHz würden sich in einer Sekunde

<math>\frac{12\,000\,000}{256 \cdot 256} = 183{,}10546875</math>

256-Schritt Overflow Interrupts ergeben. Das kann man in 183 volle 256-Schritt Overflows plus 0,10546875 * 256 = 27 Stück 1-Schritt-Overflows bzw. ein 27-Schritt Overflow aufteilen. Insgesamt also 184 Overflow-Interrupts. Im 183. Interrupt muss der Startwert geändert werden und im 184. Interrupt kann der Sekundenzähler erhöht werden.

Die Ungenauigkeit kann in das Programm, weil der Timer ja weiterläuft, während sich das Programm in der ISR befindet. Wenn dann der Startwert vom Programm aus gesetzt wird, berücksichtigt das nicht den Wert der schon bis dahin gezählt ist. Mit dem Makro GENAUIGKEIT kann man in der Richtung etwas experimentieren...

Genug Zahlenspielerei. Der Rest des Programmes ist wieder anschaulicher. Die bereits bekannte Funktion rs232 wurde in die Funktion rs232_io geändert, so dass die Eingabe von Stunden, Minuten und Sekunden möglich ist. Was per RS232 eingegeben werden soll, kann mit dem TASTER1 bestimmt werden: 1. Tastendruck Sekunden, 2. Tastendruck Minuten, 3. Tastendruck Stunden. 4. Tastendruck Anzeige Uhrzeit auf RS232.

<syntaxhighlight lang="c">

//
// Pollin Funk-AVR-Evaluationsboard v1.1
// PFA_uhr.c
// v 1.0
//

/*
Atmega8

Externer Quarz-Oszillator: 12 MHz
Optimierung: -Os

RS232-Einstellungen:
9600 Baud, 8 Bits, No Parity, 1 Stopbit
*/

#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>
#include <avr/interrupt.h>

#include "PFA_funkhw.h"
#include "PFA_rs232.h"
#include "lcd-routines.h"

/* in Millisekunden */
#define ENTPRELLUNG 10

volatile uint8_t stunden;
volatile uint8_t minuten;
volatile uint8_t sekunden;

//
// 0: 183x256 + 1x27
// 1: 183x256 + 1x27 durchlaufendes TCNT0 berücksichtigt
// 2: 325x125
//
#define GENAUIGKEIT 0

#if ( GENAUIGKEIT == 1 )
volatile uint8_t tcnt0;
#endif

#if ( GENAUIGKEIT == 2 )
#define RELOAD 125
#define COUNT 375
#endif

ISR(TIMER0_OVF_vect)
{
#if ( GENAUIGKEIT == 2 )
static uint16_t ticks = 0;

TCNT0 = 256 - RELOAD;

ticks += 1;

if ( ticks == COUNT )
{
// 1 Sekunde ist um.
sekunden += 1;

if ( sekunden == 60 )
{
sekunden = 0;
minuten += 1;
}

if ( minuten == 60 )
{
minuten = 0;
stunden += 1;
}

if ( stunden == 24 )
stunden = 0;

// nächste Runde
ticks = 0;
}
#else
static uint8_t ticks = 0;

ticks += 1;

if ( ticks == 183 )
{
// Letzter Zeitabschnitt kürzer, um auf 1s zu kommen
#if ( GENAUIGKEIT == 1 )
tcnt0 = TCNT0;
TCNT0 = 256 - 27 + TCNT0;
#else
TCNT0 = 256 - 27;
#endif
}
else if ( ticks == 184 )
{
// 1 Sekunde ist um.
sekunden += 1;

if ( sekunden == 60 )
{
sekunden = 0;
minuten += 1;
}

if ( minuten == 60 )
{
minuten = 0;
stunden += 1;
}

if ( stunden == 24 )
stunden = 0;

// nächste Runde
ticks = 0;
}
#endif
}

void uhr_init(void)
{
// Rrescaler 256
TCCR0 = (1<<CS02) | (0<<CS01) | (0<<CS00);

// Zählregister
#if ( GENAUIGKEIT == 2 )
TCNT0 = 256 - RELOAD;
#else
TCNT0 = 0;
#endif

// Overflow-Flag löschen
TIFR = (1<<TOV0);

// Timer0 Overflow enable
TIMSK |= (1<<TOIE0);

// Interrupts global einschalten
sei();
}

void uhrzeit_lcd(void)
{
static int16_t alter_wert = -1;
char puffer[4]; // max. 3 Ziffern (uint8_t) plus 1 Nullbyte

if ( sekunden != alter_wert )
{
// Ausgabe nur bei Änderungen
alter_wert = sekunden;

lcd_clear();

itoa((int) stunden+100, puffer, 10);
lcd_string(&puffer[1]);

lcd_string(" : ");

itoa((int) minuten+100, puffer, 10);
lcd_string(&puffer[1]);

lcd_string(" : ");

itoa((int) sekunden+100, puffer, 10);
lcd_string(&puffer[1]);
}
}

void ausgabe_led(uint8_t wert)
{
if (wert & (1<<0)) // Bit 0
LED_AN(LED1);
else
LED_AUS(LED1);

if (wert & (1<<1)) // Bit 1
LED_AN(LED2);
else
LED_AUS(LED2);
}

int main(void)
{
uint8_t alter_tastenzustand = TASTE_AUF;
uint8_t zaehler = 0;

DDRB &= ~(1<<TASTER); // Port B: Eingang für Taster
DDRD |= (1<<LED1) | (1<<LED2); // Port D: Ausgang für LED1 und LED2

UART_init();
UART_putchar(FORMFEED);

lcd_init();

uhr_init();

while (1)
{
// Bekannte Uhrzeit auf LCD ausgeben
uhrzeit_lcd();

// ggf. Kommando von TASTER1 einlesen
if ( TASTER_GEDRUECKT() )
{
#if ENTPRELLUNG
_delay_ms(ENTPRELLUNG);
if ( TASTER_GEDRUECKT() )
#endif /* ENTPRELLUNG */
{
// Wechsel von OFFEN nach GESCHLOSSEN?
if ( alter_tastenzustand == TASTE_AUF )
{
zaehler++;
alter_tastenzustand = TASTE_ZU;
}
}
}

if ( !TASTER_GEDRUECKT() )
{
#if ENTPRELLUNG
_delay_ms(ENTPRELLUNG);
if ( !TASTER_GEDRUECKT() )
#endif /* ENTPRELLUNG */
alter_tastenzustand = TASTE_AUF;
}

// Feedback TASTER1 auf LEDs
ausgabe_led(zaehler); // LED Ausgabe

// Je nach TASTER1-Eingabe Uhrzeit per RS232 ändern oder anzeigen
switch (zaehler % 4)
{
case 3:
rs232_io("Stunden = ", &stunden, 0, 23);
break;

case 2:
rs232_io("Minuten = ", &minuten, 0, 59);
break;

case 1:
rs232_io("Sekunden = ", &sekunden, 0, 59);
break;

case 0:
default:
#if ( GENAUIGKEIT == 1 )
if ( tcnt0 != 0 )
{
char puffer[4];
UART_puts("TCNT0 = ");
itoa((int) tcnt0, puffer, 10);
UART_puts(puffer);
UART_puts("\r\n");
}
#endif
rs232_uhrzeit_zeigen(stunden, minuten, sekunden);
break;
}
}
}

// EOF PFA_uhr.c

</syntaxhighlight>

'''PFA_funkhw.h''' - Definitionen für das PFA ;-) Board
<syntaxhighlight lang="c">

//
// Pollin Funk-AVR-Evaluationsboard v1.1
// PFA_funkhw.h
// v 1.0
//

/*
Atmega8
*/

// LEDs sind high-active geschaltet
#define LED_AN(LED) (PORTD |= (1<<(LED)))
#define LED_AUS(LED) (PORTD &= ~(1<<(LED)))
#define LED_TOGGLE(LED) (PORTD ^= (1<<(LED)))
#define LED1 PD6
#define LED2 PD5

// TASTER ist high-active geschaltet
#define TASTER PB1
#define TASTER_GEDRUECKT() (PINB & (1<<TASTER))
#define TASTE_AUF 0
#define TASTE_ZU 1

// EOF PFA_funkhw.h

</syntaxhighlight>

'''PFA_rs232.c''' - Erweiterte rs232-Funktionen
<syntaxhighlight lang="c">

//
// Pollin Funk-AVR-Evaluationsboard v1.1
// PFA_rs232.c
// v 1.0
//

#include "PFA_rs232.h"

static void wert_ausgeben(char *s, uint8_t wert)
{
char puffer[4]; // uint8_t hat max. 3 Dezimalstellen plus 1 Nullbyte = 4 Bytes

// Einleitender Text, was im folgenden ausgegeben wird
UART_puts(s);

// Zahl in Ziffernfolge umwandeln. Hier zuerst in Dezimalziffern
itoa((int) wert, puffer, 10);
UART_puts(puffer);

// Zeilenabschluss zur Formatierung der Anzeige
UART_puts("\r\n");
}

void rs232_io(char *s, uint8_t *wert, uint8_t min, uint8_t max)
{
static int16_t alter_wert = -1;
uint8_t anzahl_ziffern;
uint8_t zeichen;
char puffer[EINGABE_MAX];

// Eingabe über RS232

// Ohne Warten prüfen, ob Zeichen an UART vorhanden
if ( UART_peekchar() )
{
// Zeichen ist da.

// Aktuellen Wert ausgeben

// Neue Seite im Terminal anfordern.
// Bewirkt ein Löschen des Bildschirms
UART_putchar(FORMFEED);

wert_ausgeben(s, *wert);

// Neuen Wert eingeben

// Initialisierung
UART_puts("Eingabe> ");
anzahl_ziffern = EINGABE_START;

// Eingabeschleife
do
{
// 1. bereits Zeichen am UART Eingang abholen
// in weiteren Schleifen auf neue Zeichen warten
zeichen = UART_getchar();

// Zeichen auswerten
if ( (zeichen == '-') && (anzahl_ziffern == EINGABE_START) )
{
// MINUS
UART_puts(" -1");
UART_puts("\r\n");
if (*wert > min)
*wert -= 1;
break;
}
else if ( (zeichen == '+') && (anzahl_ziffern == EINGABE_START) )
{
// PLUS
UART_puts(" +1");
UART_puts("\r\n");
if (*wert < max)
*wert += 1;
break;
}
else if ( (zeichen == '\n') || (zeichen == '\r') )
{
// ENTER oder RETURN: Abschluss der Eingabe
break;
}
else if ( (zeichen >= '0') && (zeichen <= '9') )
{
// Eingabe einer Ziffer
UART_putchar(zeichen); // Echo
puffer[anzahl_ziffern++] = zeichen;
puffer[anzahl_ziffern] = 0;
}
else
{
// Sonstiges Zeichen ist für uns illegal
anzahl_ziffern = EINGABE_ABBRUCH;
UART_puts(" Abbruch.");
UART_puts("\r\n");
break;
}
}
while ( anzahl_ziffern < EINGABE_MAX );

// Eingabe prüfen
if ( anzahl_ziffern != EINGABE_ABBRUCH )
{
// Ziffern in Zahl umwandeln
int i = atoi(puffer);

// z. B. erlaubter Wertebereich
if ( (i >= min) && (i <= max) )
{
UART_puts(" Ok.");
UART_puts("\r\n");
*wert = (uint8_t) i;
}
else
UART_puts(" Ung\201ltig.\r\n"); // \201 ist ü in Oktalschreibweise
}
}

// Ausgabe auf RS232 (s.oben)
// bei nur Änderung des Wertes gegenüber der letzten Ausgabe
//
// alter_wert wurde mit -1 initialisiert. Das ist ausserhalb
// des Wertebereichs von *wert, D.h. spätere Abfrage, ob
// (alter_wert != *wert) ist, ist beim ersten Durchlauf wie
// gewünscht wahr,
//
if (alter_wert != *wert)
{
alter_wert = *wert;
wert_ausgeben(s, *wert);
}
}

void rs232_uhrzeit_zeigen(uint8_t stunden, uint8_t minuten, uint8_t sekunden)
{
static int16_t alte_sekunden = -1;
char puffer[23];

if ( alte_sekunden != sekunden )
{
// Neue Seite im Terminal anfordern.
// Bewirkt ein Löschen des Bildschirms
UART_putchar(FORMFEED);

// Zahl in Ziffernfolge umwandeln. Hier zuerst in Dezimalziffern
itoa((int) stunden+100, puffer, 10);
UART_puts(&puffer[1]);

UART_puts(" : ");

// Zahl in Ziffernfolge umwandeln. Hier zuerst in Dezimalziffern
itoa((int) minuten+100, puffer, 10);
UART_puts(&puffer[1]);

UART_puts(" : ");

// Zahl in Ziffernfolge umwandeln. Hier zuerst in Dezimalziffern
itoa((int) sekunden+100, puffer, 10);
UART_puts(&puffer[1]);

// Zeilenabschluss zur Formatierung der Anzeige
UART_puts("\r\n");

alte_sekunden = sekunden;
}
}

</syntaxhighlight>

'''PFA_rs232.h''' - Prototypen zu den rs232-Funktionen
<syntaxhighlight lang="c">

//
// Pollin Funk-AVR-Evaluationsboard
// PFA_uart.h
// v 1.0
//

#include <avr/io.h>
#include <stdlib.h>
#include "PFA_uart.h"

#ifndef FORMFEED
#define FORMFEED '\014'
#endif

#define EINGABE_START 0
#define EINGABE_ABBRUCH EINGABE_START
#define EINGABE_MAX 3

void rs232_io(char * s, uint8_t *wert, uint8_t min, uint8_t max);
void rs232_uhrzeit_zeigen(uint8_t stunden, uint8_t minuten, uint8_t sekunden);

// EOF PFA_uart.h

</syntaxhighlight>

'''PFA_uart.c''' - UART Grundfunktionen (aus ehemaligem rs232.c herausgezogen)
<syntaxhighlight lang="c">

//
// Pollin Funk-AVR-Evaluationsboard v1.1
// PFA_uart.c
// v 1.0
//

#include "PFA_uart.h"

/*
Atmega8

Externer Quarz-Oszillator: 12 MHz
Optimierung: -Os

RS232-Einstellungen:
9600 Baud, 8 Bits, No Parity, 1 Stopbit
*/
void UART_init(void)
{
// Bausrate setzen
// 9600 Baud bei F_CPU 12 MHz
// (Baudratenfehler = +0,2%)
UBRRH = (uint8_t) ((F_CPU / (16 * 9600L) - 1) >> 8);
UBRRL = (uint8_t) (F_CPU / (16 * 9600L) - 1);

// Empfangen, Senden erlauben
UCSRB = (1<<RXEN) | (1<<TXEN);

// Frame Format: 8 Bits, No Parity, 1 Stopbit
UCSRC = (1<<URSEL) | ((1<<UCSZ1) | (1<<UCSZ0)) | ((0<<UPM1) | (0<<UPM0)) | (0<<USBS);
}

// Auf Zeichen im UART Eingang prüfen
uint8_t UART_peekchar(void)
{
// sofort zurückkehren und Zustand melden
return UCSRA & (1<<RXC);
}

// Auf Zeichen im UART Eingang warten
uint8_t UART_getchar(void)
{
// Warte bis UART Eingang voll
while ( !(UCSRA & (1<<RXC)) )
;
return UDR;
}

// Zeichen in UART Ausgang geben
void UART_putchar(char z)
{
// Warte bis UART Ausgang frei
while ( !(UCSRA & (1<<UDRE)) )
;
UDR = z;
}

// Zeichenkette (String) in UART Ausgang geben
void UART_puts(char *s)
{
while ( *s )
{
UART_putchar(*s);
s++;
}
}

// EOF PFA_uart.c

</syntaxhighlight>

'''PFA_uart.h''' - Prototypen zu den UART Grundfunktionen
<syntaxhighlight lang="c">

//
// Pollin Funk-AVR-Evaluationsboard
// PFA_uart.h
//

#include <avr/io.h>

void UART_init(void);

// Auf Zeichen im UART Eingang prüfen
uint8_t UART_peekchar(void);

// Auf Zeichen im UART Eingang warten
uint8_t UART_getchar(void);

// Zeichen in UART Ausgang geben
void UART_putchar(char z);

// Zeichenkette (String) in UART Ausgang geben
void UART_puts(char *s);

// EOF PFA_uart.h

</syntaxhighlight>

=== Uhr mit 7-Segment-Anzeige ===

Die Anzeige auf dem kleinen LCD ist nett, aber eine zusätzliche 7-Segment-Anzeige mit vier Ziffern für Stunden und Minuten wäre schöner!

Aber inzwischen wird es schon knapp mit den freien Pins am ATmega8, weil das LCD am Aufbau installiert bleiben soll und dadurch Port C belegt ist. Daneben sind auch drei I/O-Pins durch Taster und die beiden LEDs.belegt und zwei Pins sind durch die UART weg... Aber zum Glück kann man den Bedarf an Pins durch verschieden Massnahmen senken:

[[Bild:PFA uhr 7segment foto.jpg|thumb|right|256px|Uhr mit 7-Segment-Anzeige (Pollin Funk-AVR-Evaluationsboard)]]

# Ohne Zusatzmassnahmen bräuchte man 4 Ziffern * 7 Segmente. Gesamtbedarf: 28 Output-Pins ;-(
# Erste Reduzierungsstufe: 4 Steuerleitungen für die Stromzufuhr der 4 Ziffern und 7 Steuerleitungen für alle Ziffern gemeinsam. Die Stromzufuhr wird zyklisch jeweils einer Ziffer zugeordnet. Wenn die Ziffer an der Reihe ist, werden die Segmente mit den Segmentsteuerleitungen eingestellt. Gesamtbedarf: 4 + 7 = 11 Output-Pins
# Zweite Reduzierungsstufe: Die Segmentsteuerleitungen werden von einem '''BCD-nach-7Segment-Decoder''' angesprochen. Um eine BCD-Zahl an den Decoder zu geben werden am AVR 4 Steuerleitungen benötigt. Gesamtbedarf: 4 + 4 = 8 Output-Pins
# Dritte Reduzierungsstufe: Die Segmentsteuerleitungen werden von einem [[AVR-Tutorial:_Schieberegister|Schieberegister]] angesprochen. Um das Schieberegister zu füttern, werden am AVR 2-3 Steuerleitungen (je nach Art des Schieberegisters) benötigt. Gesamtbedarf: 4 + 2 bis 3 = 6 bis 7 Output-Pins
# Vierte Reduzierungsstufe: Die Segmentsteuerleitungen und die Versorgungssteuerleitungen werden von je einem Schieberegister bedient. Und es wird eine gemeinsame Clock-Steuerleitung verwendet. Gesamtbedarf: 2x 2 bis 3 minus 1 = 3 bis 5 Output-Pins
# Fünfte Reduzierungsstufe...: Nur 1 Pin zur Ansteuerung, geht das? Auch das geht, wenn z. B. die Ausgabe seriell zu einem weiteren '''Mikrocontroller''' geschickt wird, der dann eine eigene Displaysteuerung besitzt.

Zufällig fand sich in meiner Bastelkiste ein BCD-nach-7Segment-Decoder nämlich der CA3161 von Intersil sowie vier grüne Siebensegmentanzeigen von einem früheren Drehzahlmesser-Projekt. Die sollen jetzt dem Recycling zugeführt werden.

Die Verkabelung ist experimentell gestaltet. Als einfaches Steckbrett zum Anschluss an die 40-polige Steckerleiste J4 wird ein 40-poliges IDE Kabel eines geplünderten Rechners benutzt. Von dem 40-poligen Kabel geht es dann über ein längeres 10-poliges Kabel (8 plus +5V und GND) zum Aufbaubrett mit der Zusatzschaltung.

Achtung: Wenn ein solches IDE-Kabel in eigenen Schaltungen benutzt wird, vorher kontrollieren, ob die benötigten Pins 1:1 verbunden sind (Danke an Markus [http://www.mikrocontroller.net/topic/167829#1604209])

Plan der Leitungszuordnung:

{| class="wikitable sortable" id="timer0-12mhz-2"
|-
| Funktion
| Bezeichnung am ATmega8
| Pin an ATmega8-16PI
| Pin an 40-pol. J4
| Leitung auf 10-pol. Verbindung
| Pin an CA3161
| Bezeichnung am CA3161
| Transistor-Nr.
|-
| Versorgung Minuten-Einer
| PB0
| 14
| 9
| 1
| -
| -
| Q1
|-
| Versorgung Minuten-Zehner
| PD2
| 4
| 28
| 2
| -
| -
| Q2
|-
| Versorgung Stunden-Einer
| PD3
| 5
| 29
| 3
| -
| -
| Q3
|-
| Versorgung Stunden-Zehner
| PD4 (Anm. 1)
| 6
| 30
| 4
| -
| -
| Q4
|-
| Segmente BCD 20
| PB2
| 16
| 13
| 5
| 7
| 20
| -
|-
| Segmente BCD 21
| PB3
| 17
| 14
| 6
| 1
| 21
| -
|-
| Segmente BCD 22
| PB4
| 18
| 15
| 7
| 2
| 22
| -
|-
| Segmente BCD 23
| PB5
| 19
| 16
| 8
| 6
| 23
| -
|-
|}

[[Bild:PFA uhr 7segment SPlan.png|thumb|right|256px|Uhr mit 7-Segment-Anzeige (Pollin Funk-AVR-Evaluationsboard)]]

Im nebenstehenden Bild ist der Versuch eines ersten Schaltplans zu sehen. Dabei wurde [[KiCAD]] verwendet. Bei der Erstellung des "Spezial-IC" CA3161 war der [http://kicad.rohrbacher.net/quicklib.php Quick KICAD Library Component Builder] sehr hilfreich. Achtung: Es ist nicht der komplette Aufbau von Spannungsversorgung und Beschaltung des ATmega8 zu sehen, lediglich die Bauteile und Verbindungen für dieses Beispiel sind eingezeichnet!

Bei den 7-Segmentanzeigen handelt es sich um Anzeigen vom Typ Kingbright SA52-11GWA (''common anode'' , 13 mm, grün). Die Versorgung jeweils einer Ziffer mit Strom erfolgt über einen geschalteten PNP-Transistor Typ BC558B mit 1,5 kOhm [[Basiswiderstand]]. Die Strombegrenzung für die Anzeige wird über je einen 220Ω [[LED#Vorwiderstand|Vorwiderstand]] pro Segmentleitung gemacht. Diese Dimensionierung ist noch nicht optimal, denn die Ziffern können ruhig noch etwas heller leuchten. Bei dieser Dimensionierung benötigt eine Ziffer im [[Multiplexen|Multiplexbetrieb]] ca. 3 mA Strom (Messung mit Multimeter zwischen Transistor und CA Anschluss). Im Dauerbetrieb ist das absolute Maximum Rating für diese Anzeige 25 mA.

Anm. 1: Bei '''PD4''' heisst es aufpassen! Dieser Pin ist auch über einen 180Ω Vorwiderstand an den Optokoppler angeschlossen, um die Versorgungsspannung eines ggf, installierten RFM-Modus einzuschalten. Das Ganze wirkt dann als starker Pulldown-Widerstand, d.h. diese Leitung an diesem Pin wird im Reset-Zustand LOW gezogen und dadurch öffnet Q4 und lässt Ziffer 4 leuchten, wenn gleichzeitig mein ISP-Adapter (STK200-komp.) an J2 angeschlossen ist und dadurch PB3 (MOSI) und PB5 (SCK) auf LOW gezogen werden... Die anderen Versorgungspins sind im Reset im Tristate-Modus, d.h. die Ziffern 1 bis 3 sind aus, weil Q1 bis Q3 gesperrt sind.

Das führt zu einer grundsätzlichen und wichtigen Überlegung in einem Projekt - Was macht die Periferie, wenn der Mikrocontroller bzw. das Programm darin keine Kontrolle hat? Beispielsweise beim Reset oder beim ISP-Programmieren oder beim Brownout... Im Hinblick auf diese Überlegungen ist die hier verwendete Kombination aus Schaltung und Programm unsicher!

Der Programmcode ist wieder in mehrere Module gegliedert:

* PFA_uhr_7segment.c - Das Hauptprogramm
* PFA_7segment.c - Die eigentliche Ansteuerung
* PFA_7segment.h - Die Prototypen für PFA_7segment.c
* sowie diese Unveränderten Dateien aus dem Uhr-Beispiel (s.o.): PFA_funkhw.h, PFA_rs232.c, PFA_rs232.h, PFA_uart.c, PFA_uart.h, lcd-routines.c, lcd-routines.h

'''PFA_uhr_7segment.c''' - Das Hauptprogramm

Die Ansteuerung der neuen Anzeige (Bsp:led7segment_multiplex) ist im Timer0-Overflow-Interrupt eingeklinkt. Sie wird bei jedem (!) Timer-Overflow-Interrupt aufgerufen, d.h. sie darf nicht zulange arbeiten, damit keine weiteren Interrupts auflaufen. Der Timer wurde anderes als im Uhr-Beispiel eingerichtet, nämlich mit gleichlangen Overflow-Intervallen. Die Steuerdaten für die sieben Segmente pro Ziffer werden bei möglichen Änderungen, d.h. bei einem Sekundenwechsel, vorausberechnet und in einem Feld (Bsp: led7segment_ziffern) gespeichert. Die Initialisierung der neuen Anzeige erfolgt einmalig zu Beginn des Hauptprogramms (Bsp: led7segment_init).

<syntaxhighlight lang="c">

//
// Pollin Funk-AVR-Evaluationsboard v1.1
// PFA_uhr_7segment.c
// v 1.0
//

/*
Atmega8

Externer Quarz-Oszillator: 12 MHz
Optimierung: -Os

RS232-Einstellungen:
9600 Baud, 8 Bits, No Parity, 1 Stopbit
*/

#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>
#include <avr/interrupt.h>

#include "PFA_funkhw.h"
#include "PFA_rs232.h"
#include "PFA_7segment.h"
#include "lcd-routines.h"

/* in Millisekunden */
#define ENTPRELLUNG 10

volatile uint8_t stunden;
volatile uint8_t minuten;
volatile uint8_t sekunden;

//
// 0: 183x256 + 1x27
// 1: 183x256 + 1x27 durchlaufendes TCNT0 berücksichtigt
// 2: 325x125
//
#define RELOAD 125
#define COUNT 375

ISR(TIMER0_OVF_vect)
{
static uint16_t ticks = 0;

TCNT0 = 256 - RELOAD + TCNT0;

led7segment_multiplex();

ticks += 1;
if ( ticks == COUNT )
{
// 1 Sekunde ist um.
sekunden += 1;

if ( sekunden == 60 )
{
sekunden = 0;
minuten += 1;
}

if ( minuten == 60 )
{
minuten = 0;
stunden += 1;
}

if ( stunden == 24 )
stunden = 0;

// 1x möglichst viel vorberechnen, damit die Multiplex-Routine schnell ist
#if 1
// Äktschn beim Entwickeln ;-)
led7segment_ziffern[0] = (sekunden % 10) << 2;
led7segment_ziffern[1] = (sekunden / 10) << 2;
led7segment_ziffern[2] = (minuten % 10) << 2;
led7segment_ziffern[3] = (minuten / 10) << 2;
#else
led7segment_ziffern[0] = (minuten % 10) << 2;
led7segment_ziffern[1] = (minuten / 10) << 2;
led7segment_ziffern[2] = (stunden % 10) << 2;
led7segment_ziffern[3] = (stunden / 10) << 2;
#endif
// nächste Runde
ticks = 0;
}
}

void uhr_init(void)
{
// Rrescaler 256
TCCR0 = (1<<CS02) | (0<<CS01) | (0<<CS00);

// Zählregister
TCNT0 = 0;

// Overflow-Flag löschen
TIFR = (1<<TOV0);

// Timer0 Overflow enable
TIMSK |= (1<<TOIE0);

// Interrupts global einschalten
sei();
}

void uhrzeit_lcd(void)
{
static int16_t alter_wert = -1;
char puffer[4]; // max. 3 Ziffern (uint8_t) plus 1 Nullbyte

if ( sekunden != alter_wert )
{
// Ausgabe nur bei Änderungen
alter_wert = sekunden;

lcd_clear();

itoa((int) stunden+100, puffer, 10);
lcd_string(&puffer[1]);

lcd_string(" : ");

itoa((int) minuten+100, puffer, 10);
lcd_string(&puffer[1]);

lcd_string(" : ");

itoa((int) sekunden+100, puffer, 10);
lcd_string(&puffer[1]);
}
}

void ausgabe_led(uint8_t wert)
{
if (wert & (1<<0)) // Bit 0
LED_AN(LED1);
else
LED_AUS(LED1);

if (wert & (1<<1)) // Bit 1
LED_AN(LED2);
else
LED_AUS(LED2);
}

int main(void)
{
uint8_t alter_tastenzustand = TASTE_AUF;
uint8_t zaehler = 0;

DDRB &= ~(1<<TASTER); // Port B: Eingang für Taster
DDRD |= (1<<LED1) | (1<<LED2); // Port D: Ausgang für LED1 und LED2

UART_init();
UART_putchar(FORMFEED);

lcd_init();

led7segment_init();

uhr_init();

while (1)
{
// Bekannte Uhrzeit auf LCD ausgeben
uhrzeit_lcd();

// ggf. Kommando von TASTER1 einlesen
if ( TASTER_GEDRUECKT() )
{
#if ENTPRELLUNG
_delay_ms(ENTPRELLUNG);
if ( TASTER_GEDRUECKT() )
#endif /* ENTPRELLUNG */
{
// Wechsel von OFFEN nach GESCHLOSSEN?
if ( alter_tastenzustand == TASTE_AUF )
{
zaehler++;
alter_tastenzustand = TASTE_ZU;
}
}
}

if ( !TASTER_GEDRUECKT() )
{
#if ENTPRELLUNG
_delay_ms(ENTPRELLUNG);
if ( !TASTER_GEDRUECKT() )
#endif /* ENTPRELLUNG */
alter_tastenzustand = TASTE_AUF;
}

// Feedback TASTER1 auf LEDs
ausgabe_led(zaehler); // LED Ausgabe

// Je nach TASTER1-Eingabe Uhrzeit per RS232 ändern oder anzeigen
switch (zaehler % 4)
{
case 3:
rs232_io("Stunden = ", &stunden, 0, 23);
break;

case 2:
rs232_io("Minuten = ", &minuten, 0, 59);
break;

case 1:
rs232_io("Sekunden = ", &sekunden, 0, 59);
break;

case 0:
default:
rs232_uhrzeit_zeigen(stunden, minuten, sekunden);
break;
}
}
}

// EOF PFA_uhr_7segment.c

</syntaxhighlight>

'''PFA_7segment.c''' - Die eigentliche Ansteuerung

<syntaxhighlight lang="c">

//
// Pollin Funk-AVR-Evaluationsboard
// PFA_7segment.c
// v 1.0
//

#include "PFA_7segment.h"
#include "PFA_funkhw.h"
#include <avr/delay.h>

uint8_t led7segment_ziffern[ANZAHL_ZIFFERN];

void led7segment_init(void)
{
DDRB |= (1<<PB0) | (1<<PB2) | (1<<PB3) | (1<<PB4) | (1<<PB5);
DDRD |= (1<<PD2) | (1<<PD3) | (1<<PD4);

// Alle Segmente aus
PORTB |= ((1<<PB2) | (1<<PB3) | (1<<PB4) | (1<<PB5)); // BCD Code 0b1111 für "Blank" an Ausgabepins

// Spannung aller Ziffern aus (neg. Logik)
PORTB |= (1<<PB0);
PORTD |= ((1<<PD2) | (1<<PD3) | (1<<PD4));
}

void led7segment_multiplex(void)
{
static uint8_t ticks = 0;

// Spannung aller Ziffern aus (neg. Logik)
PORTB |= (1<<PB0);
PORTD |= ((1<<PD2) | (1<<PD3) | (1<<PD4));

// Segmente der neuen Ziffer berechnen
PORTB = (PORTB & 0b11000011) | led7segment_ziffern[ticks];
switch ( ticks )
{
case 0:
PORTB &= ~(1<<PB0); // Spannung ein
break;
case 1:
PORTD &= ~(1<<PD2);
break;
case 2:
PORTD &= ~(1<<PD3);
break;
case 3:
PORTD &= ~(1<<PD4);
break;
default:
break;
}

// auf nächste Ziffer weiterschalten
ticks += 1;
ticks %= ANZAHL_ZIFFERN;
}

// EOF PFA_7segment.c

</syntaxhighlight>

'''PFA_7segment.h''' - Die Prototypen für PFA_7segment.c

<syntaxhighlight lang="c">

//
// Pollin Funk-AVR-Evaluationsboard v1.1
// PFA_7segment.h
// v 1.0
//

/*
Atmega8
*/

#include <avr/io.h>

#define ANZAHL_ZIFFERN 4

extern uint8_t led7segment_ziffern[];

void led7segment_init(void);

void led7segment_multiplex(void);

// EOF PFA_7segment.h

</syntaxhighlight>

Mit einem Logikanalysator kann das Multiplexen auf den einzelnen Leitungen gemessen werden (wie praktisch, dass am zweckentfremdeten IDE-Kabel eine zweite Buchsenleiste ist). Im folgenden Bild sind 5 Durchläufe der vierstelligen Anzeige dargestellt.

[[Bild:PFA uhr 7segment logik.png|Logikdiagramm der Uhr mit 7-Segment-Anzeige (Pollin Funk-AVR-Evaluationsboard)]]

In den Spuren 01 bis 04 (blau) liegen die Versorgungssteuerleitungen, die den Multiplexbetrieb steuern, und in den Spuren 05 bis 08 (rot) die BCD-codierten Segmentsteuerleitungen. Ein Zyklus (gelber Bereich) dauert ca. 10,7 ms. Dabei wird für ca. 2,7 ms die Versorgungsspannung einer Ziffer eingeschaltet, während die anderen Ziffern ausgeschaltet sind. Die Logik auf den Versorgungsleitungen ist negiert, da die verwendeten PNP-Transistoren zum Durchschalten der Versorgungsspannung bei log. 0 öffnen und bei log. 1 schliessen (siehe auch [[Transistor#PNP.2FNPN_als_Schalter.2C_wohin_mit_der_Last.3F|Transistor als Schalter]]). Nach 2,7 ms wird die Versorgungsspannung einer Ziffer gekappt, indem der zugehörige Transistor mit einem HIGH Pegel gesperrt wird und ein LOW Pegel am nächsten Transistor startet die Versorgung und damit die Sichtbarkeit der nächsten Ziffer...

=== Suppentimer ===

[[Bild:Suppe.jpg|thumb|right|175px|Motivation (schmackhaft)]]

Kennt ihr das? Da ist man am bosseln und plötzlich meldet sich der Jieper auf Futter. Was geht schnell genug zwischen Compilerlauf und Flashen - ein leckeres Tütchen Suppe... Während das Reaktionsgemisch köchelt, flugs noch ein paar LEDs eingebaut und Stunden später riecht es aus der Küche komisch und die Nachbarin klopft. Wieder mal die Zeit vergessen!

Aber es naht Abhilfe in Form des '''Suppentimers ST'''. In der ersten Ausbaustufe wird die 7-Segment-Uhr aus dem Beispiel vorher dafür genommen und es wird die Software umgeschrieben. UART und LCD werden nicht benötigt, deshalb können die Pin-Zuordnungen etwas bequemer gewählt werden. Z.B. bleiben jetzt die ISP-Leitungen an PORT B frei (Schaltplan siehe bei der Beschreibung von PFA_7segment.c).

Die Bedienung und Anzeige bekommt eine raffinierte Benutzersteuerung:

Der ST zählt nach dem Einschalten oder Reset Sekunden hoch und wenn bei der gewünschten Zahl der Taster 1 gedrückt wird, wird diese Zahl als Alarmzeit in Minuten genommen. Eine Marktrecherche hat nämlich ergeben, dass die typischen Tütchensuppen je nach Sorte im 5 bis 15 Minuten-Bereich köcheln sollen. 5-15 Sekunden zum Setzen des Alarms sind zumutbar, oder?

Zur Korrektur des Alarms kann man entweder Reset drücken, das geht immer, oder man kann Taster 1 nochmal drücken, um die gesetzte Alarmzeit zu löschen.

Bei gesetzter Alarmzeit wird links die Alarmzeit in Minuten angezeigt und rechts die aktuelle Zeit. Wenn die aktuelle Zeit gleich der Alarmzeit ist, schlägt der ST Alarm. Im Moment geschieht das durch Blinken der eingestellten Alarmzeit und Wechselblinken der LEDs (so wie in Blinky). Die aktuelle Zeit läuft weiter, so dass man abschätzen kann, wieviele Lötstellen "doch noch gehen".

Der letzte Bedienschritt ist, dass der Alarm mit einem Tastendruck an Taster 1 bestätigt werden muss. Quasi ein Nervfaktor, denn in einer späteren Hardware-Ausbaustufe könnte man drastischere Mittel einsetzen, z. B. einen 90 dB Piezosummer anwerfen oder so ähnlich.

Bei der Umsetzung in die Steuersoftware (Firmware) hilft es, wenn man den geplanten Ablauf in einem Diagramm aufzeichnet. Eine Methode dafür ist es, ein Zustandsdiagramm für eine [[Statemachine|Zustandsmaschine]] zu zeichnen. Solche ''state charts'' erleichtern auch das spätere Debuggen und mehr ([http://www.embedded.com/design/opensource/219400531 State charts can provide you with software quality insurance] von Peter Mueller auf www.embedded.com).

Die verschiedenen Zustände in obigem Usermanual sind u.a. "Nixmachen" (Sekunden hochzählen), Alarm setzen, Alarmzeit und aktuelle Zeit vergleichen, Alarmzeit löschen, Alarm geben, Alarm abschalten,...

[[Bild:PFA Suppentimer Zustand0.png|thumb|right|260px|Zustandsdiagramm]]

In Anlehnung an die erste Testsuppe TS für den ST sind die Zustände in meinem Diagramm als kleine Klöße dargestellt. Die Übergänge oder Aktionen zum Zustandswechsel zwischen den Zuständen sind durch Pfeile dargestellt. Das sind einmal die Tastendrücke oder Ergebnisse der Vergleiche (beschriftete Pfeile) oder auch automatische Übergänge im Programm bzw. drei Warteschleifen (unbeschriftete Pfeile).

Der Quellcode ist gegenüber dem Uhr Beispiel abgespeckt, da ja die UART und LCD Routinen beim ST nicht benötigt werden:

* PFA_Suppentimer.c - Das Hauptprogramm
* PFA_7segment.c - Die Ansteuerung der Anzeige (geänderte Pinzuordnung!)
* PFA_7segment.h - dazugehörige Includedatei
* PFA_funkhw.h - Definitionen für das PFA ;-) Board (unverändert)

Bevor es in den C-Code geht noch eine kleine Lesehilfe. Der Code enthält vier Hauptversionen mit steigendem Umfang bzw. einer Zusatzfunktion: Stromsparen! Welche Version übersetzt wird, wird durch das Makro SLEEP_CODE in PFA_Suppentimer.c gesteuert:

[[Bild:PFA Suppentimer Zustand1-3.png|thumb|260px|Zustandsdiagramm mit Schlafmodus]]

* 0 - keine Zusatzfunktion. Der ST arbeitet wie oben beschrieben.
* 1 bis 3 - ST fällt in einen Schlafmodus, wenn die Alarmzeit nicht innerhalb von SCHLAFENSZEIT Sekunden eingegeben wird. Im Schlafmodus wird die Anzeige abgeschaltet. Wie der Schlafmodus im Programm aussieht, steuert der Wert 1, 2 oder 3
** 1 - Zum Aufwecken aus einem simulierten Schlaf wartet der ST auf einen Tastendruck an Taster 1. Bis der Tastendruck kommt, dreht in einer aus Tasty bekannten Programmschleife Däumchen.
** 2 - Hier wird die Abfrage in der Programmschleife durch ein im Interrupt gesetztes Flag verlassen. Dazu wird eine kleine externe Hardware benötigt. An PD2 bzw. INT0 ist ein Taster 2 anzuschliessen, der per Interrupt INT0 den ST "aufweckt". Die Art des Interrupts ist hier noch frei wählbar. Noch ist das Schlafen lediglich in einer kleinen Schleife im Hauptprogramm simuliert
** 3 - Jetzt geht es richtig zur Sache. Der ST fällt, wie im Artikel [[Sleep Mode]] beschrieben, in Tiefschlaf. Das Programm läuft nicht mehr. Der Timer pennt. Nur ein mit Taster2 ausgelöster '''LOW LEVEL (!)''' Interrupt oder ein Reset wecken den Schläfer auf.

'''PFA_Suppentimer.c''' - Das Hauptprogramm

<syntaxhighlight lang="c">

//
// Pollin Funk-AVR-Evaluationsboard v1.1
// PFA_Suppentimer.c
// v 1.0
// v 1.1 - Abfrage Taster in der Hauptschleife
// Abfrage nur in den Zuständen, in denen Eingabe möglich ist
//

/*
Atmega8

Externer Quarz-Oszillator: 12 MHz
Optimierung: -Os
*/

#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>

#include "PFA_funkhw.h"
#include "PFA_7segment.h"

#if 1
// Schneller Suppentimer zum Programmentwickeln
#define TRIGGER sekunden
#else
// Langsamer Suppentimer zum Suppenkochen
#define TRIGGER minuten
#endif

// Betriebszustände des Suppentimers
#define RUHEZUSTAND 0
#define ALARM_SETZEN RUHEZUSTAND + 1 // Nicht veränderbar
#define ALARM_PRUEFEN ALARM_SETZEN + 1
#define ALARM_LOESCHEN ALARM_PRUEFEN + 1
#define ALARM_GEBEN ALARM_LOESCHEN + 1
#define ALARM_QUITTIEREN ALARM_GEBEN + 1 // Nicht veränderbar

// SLEEP_CODE = Auswahl zur schrittweisen Programmentwicklung
//
// 0: Kein SLEEP
//
// 1: SIMULATION Stufe 1 SLEEP und INT0 werden NICHT benutzt.
// Aufwachen: TASTER1 auf dem Board
//
// 2: SIMULATION Stufe 2 SLEEP wird NICHT benutzt, aber INT0 wird benutzt.
// Aufwachen: Externe TASTER2 Hardware an PD2
//
// 3: Echtes SLEEP: SLEEP und INT0 werden benutzt.
// Aufwachen: Externe TASTER2 Hardware an PD2
//
#define SLEEP_CODE 0

#if ( SLEEP_CODE > 0 )
// Weitere Zustände
#define SCHLAFEN_GEHEN ALARM_QUITTIEREN + 1
#define SCHLAFEN SCHLAFEN_GEHEN + 1
#define AUFWACHEN SCHLAFEN + 1
// Sekunden im RUHEZUSTAND bis Schlafen beginnt
#define SCHLAFENSZEIT 23
#endif /* ( SLEEP_CODE > 0 ) */

#if ( SLEEP_CODE == 2 )
// Hilfsvariable fürs Aufwachen
volatile uint8_t int0_zustand;
#endif /* ( SLEEP_CODE == 2 ) */

/* in Millisekunden */
#define ENTPRELLUNG 10

#define RELOAD 125
#define COUNT 375

/*
#define RELOAD 75
#define COUNT 625
*/

/*
#define RELOAD 25
#define COUNT 1875
*/

volatile uint8_t stunden;
volatile uint8_t minuten;
volatile uint8_t sekunden;

#if ( SLEEP_CODE > 1 )
ISR(INT0_vect)
{
#if ( SLEEP_CODE == 2 )
int0_zustand = AUFWACHEN;
#endif /* ( SLEEP_CODE == 2 ) */

#if ( SLEEP_CODE == 3 )
// set_sleep_mode(SLEEP_MODE_IDLE);
#endif /* ( SLEEP_CODE == 3 ) */
}
#endif /* ( SLEEP_CODE > 1 ) */

ISR(TIMER0_OVF_vect)
{
static uint16_t ticks = 0;

TCNT0 = 256 - RELOAD + TCNT0;

led7segment_multiplex();

ticks += 1;
if ( ticks == COUNT )
{
// 1 Sekunde ist um.
sekunden += 1;

if ( sekunden == 60 )
{
sekunden = 0;
minuten += 1;
}

if ( minuten == 60 )
{
minuten = 0;
stunden += 1;
}

if ( stunden == 24 )
stunden = 0;

// nächste Runde
ticks = 0;
}
}

void uhr_init(void)
{
// Prescaler 256 einstellen
TCCR0 = (1<<CS02) | (0<<CS01) | (0<<CS00);

// Zählregister initialisieren
TCNT0 = 256 - RELOAD;

// Overflow-Flag löschen
TIFR = (1<<TOV0);

// Timer0 Overflow erlauben
TIMSK |= (1<<TOIE0);

// Interrupts global einschalten
sei();
}

void ausgabe_led(uint8_t wert)
{
if (wert & (1<<0)) // Bit 0
LED_AN(LED1);
else
LED_AUS(LED1);

if (wert & (1<<1)) // Bit 1
LED_AN(LED2);
else
LED_AUS(LED2);
}

#if 0
// Beim Makro darf die Argumentübergabe keine Seiteneffekte haben!
// Die Codegrösse ist bei -Os in beiden Fällen gleich
#define setze_ziffer(pziffer, wert) *(pziffer) = (wert)
#else
static void setze_ziffer(uint8_t * pziffer, uint8_t wert)
{
*pziffer = wert;
}
#endif

uint8_t taster1(uint8_t jetzt_zustand, uint8_t naechster_zustand)
{
static uint8_t alter_tastenzustand = TASTE_AUF;

if ( TASTER_GEDRUECKT() )
{
#if ENTPRELLUNG
_delay_ms(ENTPRELLUNG);
if ( TASTER_GEDRUECKT() )
#endif /* ENTPRELLUNG */
{
// Wechsel von OFFEN nach GESCHLOSSEN?
if ( alter_tastenzustand == TASTE_AUF )
{
jetzt_zustand = naechster_zustand;
alter_tastenzustand = TASTE_ZU;
}
}
}

if ( !TASTER_GEDRUECKT() )
{
#if ENTPRELLUNG
_delay_ms(ENTPRELLUNG);
if ( !TASTER_GEDRUECKT() )
#endif /* ENTPRELLUNG */
alter_tastenzustand = TASTE_AUF;
}

return jetzt_zustand;
}

int main(void)
{
uint8_t zustand = RUHEZUSTAND;
uint8_t alarmzeit;

DDRB &= ~(1<<TASTER); // Port B: Eingang für Taster
DDRD |= (1<<LED1) | (1<<LED2); // Port D: Ausgang für LED1 und LED2

led7segment_init();

uhr_init();

while (1)
{
switch (zustand)
{
case RUHEZUSTAND:
setze_ziffer(&led7segment_ziffern[0], (sekunden % 10));
setze_ziffer(&led7segment_ziffern[1], (sekunden / 10));
setze_ziffer(&led7segment_ziffern[2], (0b00001111)); // BCD "blank"
setze_ziffer(&led7segment_ziffern[3], (0b00001111));

#if (SLEEP_CODE > 0)
// SLEEP?
if ( sekunden >= SCHLAFENSZEIT )
zustand = SCHLAFEN_GEHEN;
#endif /* (SLEEP_CODE > 0) */

// Aus diesem Zustand geht es
// durch Usereingabe (Tastendruck)
// nächster Zustand dann RUHEZUSTAND+1 = ALARM_SETZEN
if ( zustand == RUHEZUSTAND )
zustand = taster1(RUHEZUSTAND, ALARM_SETZEN);
break;

case ALARM_SETZEN:
alarmzeit = sekunden;
TRIGGER = 0;
zustand = ALARM_PRUEFEN;
break;

case ALARM_PRUEFEN:
if ( TRIGGER == alarmzeit )
{
zustand = ALARM_GEBEN;
}
else
{
setze_ziffer(&led7segment_ziffern[0], (TRIGGER % 10));
setze_ziffer(&led7segment_ziffern[1], (TRIGGER / 10));
setze_ziffer(&led7segment_ziffern[2], (alarmzeit % 10));
setze_ziffer(&led7segment_ziffern[3], (alarmzeit / 10));
zustand = taster1(ALARM_PRUEFEN, ALARM_LOESCHEN);
}
break;

case ALARM_LOESCHEN:
sekunden = 0;
minuten = 0;
stunden = 0;
zustand = RUHEZUSTAND;
break;

case ALARM_GEBEN:
setze_ziffer(&led7segment_ziffern[0], (TRIGGER % 10));
setze_ziffer(&led7segment_ziffern[1], (TRIGGER / 10));

// Ziffer 3+4: Alarmzeit und LEDs blinken im Sekundentakt
if ( (sekunden & 1) )
{
ausgabe_led(2);
setze_ziffer(&led7segment_ziffern[2], (0b00001111)); // BCD "blank"
setze_ziffer(&led7segment_ziffern[3], (0b00001111));
}
else
{
ausgabe_led(1);
setze_ziffer(&led7segment_ziffern[2], (alarmzeit % 10));
setze_ziffer(&led7segment_ziffern[3], (alarmzeit / 10));
}

// Aus diesem Zustand geht es nur durch
// Usereingabe (Tastendruck) raus!
// nächster Zustand dann ALARM_GEBEN+1 = ALARM_QUITTIEREN
zustand = taster1(ALARM_GEBEN, ALARM_QUITTIEREN);
break;

case ALARM_QUITTIEREN:
sekunden = 0;
minuten = 0;
stunden = 0;
zustand = RUHEZUSTAND;
break;

#if ( SLEEP_CODE > 0 )
case SCHLAFEN_GEHEN:
led7segment_exit();

#if ( SLEEP_CODE == 2 )
int0_zustand = SCHLAFEN;
// PD2 ist Input, internen Pullup ein
PORTD |= (1<<PD2);
// INT0 z. B. bei fallender Flanke
MCUCR |= (1<<ISC01) | (0<<ISC00);
// Anstehende INT0 löschen (durch 1 schreiben)
GIFR |= (1<<INTF0);
// Wecker stellen: INT0 enable, sei läuft bereits (uhr_init)
GICR |= (1<<INT0);
#endif /* ( SLEEP_CODE == 2 ) */

#if ( SLEEP_CODE == 3 )
// Tiefschlaf!
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// PD2 ist Input, internen Pullup ein
PORTD |= (1<<PD2);
// ##############################################
// # ACHTUNG: nur LOW LEVEL Interrupt möglich ! #
// ##############################################
MCUCR |= (0<<ISC01) | (0<<ISC00);
// Anstehende INT0 löschen (durch 1 schreiben)
GIFR |= (1<<INTF0);
// Wecker stellen: INT0 enable, sei läuft bereits (uhr_init)
GICR |= (1<<INT0);
#endif /* ( SLEEP_CODE == 3 ) */

zustand = SCHLAFEN;
break;

case SCHLAFEN:
ausgabe_led(0);

#if ( SLEEP_CODE == 1 )
// Tastendrücken abwarten = Aufwachen
while ( taster1(1, 0) )
;
#endif /* SLEEP_CODE == 1 */

#if ( SLEEP_CODE == 2 )
// Schlafen
while ( int0_zustand == SCHLAFEN )
;
#endif /* ( SLEEP_CODE == 2 ) */

#if ( SLEEP_CODE == 3 )
// Und weg...
sleep_mode();
// Hier geht es bei SLEEP_MODE_PWR_DOWN !!!
// nur nach einem INT0-Interrupt weiter
#endif /* ( SLEEP_CODE == 3 ) */

zustand = AUFWACHEN;
break;

case AUFWACHEN:
#if (( SLEEP_CODE == 2 ) || ( SLEEP_CODE == 3 ))
// INT0 disable, sei läuft weiter (siehe uhr_init)
GICR &= ~(1<<INT0);

// PD2 bleibt Input, internen Pullup aus
PORTD &= ~(1<<PD2);
#endif /* ( SLEEP_CODE == 2 ) || ( SLEEP_CODE == 3 ) */

sekunden = 0;
minuten = 0;
stunden = 0;
led7segment_init();
zustand = RUHEZUSTAND;
break;
#endif /* ( SLEEP_CODE > 0 ) */
}

if ( zustand != ALARM_GEBEN ) // Blinken nicht stören!
ausgabe_led(zustand); // Feedback auf LEDs
}
}

// EOF PFA_Suppentimer.c
</syntaxhighlight>

[[Bild:PFA Suppentimer SPlan.png|thumb|256px|Teil-Schaltplan Suppentimer ST. Details zur 7-Segmentanzeige siehe Beispiel Uhr mit 7-Segmentanzeige]]

'''PFA_7segment.c''' - Die Ansteuerung der Anzeige (geänderte Pinzuordnung!)

Dieser Quellcode enthält die Grundansteuerung der 7-Segment-Anzeige mit den neu zugeordneten Pins. Die Hardware wurde ausserdem um einen Taster 2 (Aufwecktaster) und eine Anschaltung der Versorgungsspannung des Anzeigeteils ergänzt, um tatsächlich einen energiesparenden und erholsamen Schlaf zu haben. OK es geht mehr ums Prinzip, denn der nicht abschaltbare Rest des Evaluationsboards (Netz-LED, Spannungswandler, MAX232) saugen schon noch im zig Milliampere-Bereich.

<syntaxhighlight lang="c">

//
// Pollin Funk-AVR-Evaluationsboard
// PFA_7segment.c
//
// v 1.0
// v 1.1 - Pinbelegung geändert
//

#include "PFA_7segment.h"
#include "PFA_funkhw.h"
#include <avr/delay.h>

uint8_t led7segment_ziffern[ANZAHL_ZIFFERN];
static uint8_t led7segment_enabled = 0;

static void led7segment_power_off(void)
{
DDRB |= (1<<PB0);
PORTB &= ~(1<<PB0);
}

static void led7segment_power_on(void)
{
DDRB |= (1<<PB0);
PORTB |= (1<<PB0);
}

void led7segment_init(void)
{
uint8_t i;

for (i = 0; i < ANZAHL_ZIFFERN; i++)
led7segment_ziffern[i] = 0b00001111; // BCD Blank

// Spannung aller Ziffern aus (neg. Logik)
DDRD |= (1<<PD0) | (1<<PD1) | (1<<PD2) | (1<<PD3);
PORTD |= (1<<PD0) | (1<<PD1) | (1<<PD2) | (1<<PD3);

// Versorgungsspannung an
led7segment_power_on();

// Alle Segmente der Ziffern aus
DDRC |= (1<<PC0) | (1<<PC1) | (1<<PC2) | (1<<PC3);
PORTC |= ((1<<PC0) | (1<<PC1) | (1<<PC2) | (1<<PC3)); // BCD Code 0b1111 für "Blank" an Ausgabepins

led7segment_enabled = 1;
}

void led7segment_exit(void)
{
uint8_t i;

for (i = 0; i < ANZAHL_ZIFFERN; i++)
led7segment_ziffern[i] = 0b00001111; // BCD Blank

// RESET-Zustand: Pins Input und Tristate
DDRD &= ~((1<<PD0) | (1<<PD1) | (1<<PD2) | (1<<PD3));
PORTD &= ~((1<<PD0) | (1<<PD1) | (1<<PD2) | (1<<PD3));

// RESET-Zustand: Pins Input und Tristate
DDRC &= ~((1<<PC0) | (1<<PC1) | (1<<PC2) | (1<<PC3));
PORTC &= ~((1<<PC0) | (1<<PC1) | (1<<PC2) | (1<<PC3));

// Versorgungsspannung aus
led7segment_power_off();

led7segment_enabled = 0;
}

void led7segment_multiplex(void)
{
static uint8_t ticks = 0;

if ( led7segment_enabled )
{
// Spannung aller Ziffern aus (neg. Logik)
PORTD |= (1<<PD0) | (1<<PD1) | (1<<PD2) | (1<<PD3);

// Segmente der neuen Ziffer berechnen
PORTC = (PORTC & 0b11110000) | led7segment_ziffern[ticks];
switch ( ticks )
{
case 0:
PORTD &= ~(1<<PD0); // Spannung ein
break;
case 1:
PORTD &= ~(1<<PD1);
break;
case 2:
PORTD &= ~(1<<PD2);
break;
case 3:
PORTD &= ~(1<<PD3);
break;
default:
break;
}

// auf nächste Ziffer weiterschalten
ticks += 1;
ticks %= ANZAHL_ZIFFERN;
}
}

// EOF PFA_7segment.c
</syntaxhighlight>

'''PFA_7segment.h''' - dazugehörige Includedatei

<syntaxhighlight lang="c">

//
// Pollin Funk-AVR-Evaluationsboard v1.1
// PFA_7segment.h
// v 1.1
//

/*
Atmega8
*/

#include <avr/io.h>

#define ANZAHL_ZIFFERN 4

extern uint8_t led7segment_ziffern[];

void led7segment_init(void);

void led7segment_exit(void);

void led7segment_multiplex(void);

// EOF PFA_7segment.h
</syntaxhighlight>

'''Redesign der Hardware'''

[[Bild:PFA Suppentimer SPlan SR.png|thumb|256px|Redesign-Schaltplan Suppentimer ST mit Schieberegister '''74HC164''']]

Das IC CA3161 ist nicht mehr gut erhältlich. Deshalb wurde die Schaltung mit einem Schieberegister (''8 Bit Serial Shift Register'') aus der [[74xx]] Familie umgebaut. Statt dem 74xx595 wie im [[AVR-Tutorial: Schieberegister]] beschrieben, wurde das einfachere '''74HC164''' verwendet. Das 74xx595 hätte ich bestellen müssen und das 74HC164 konnte ich kurzfristig organisieren ;-) Die Routinen zur Ansteuerung befinden sich in der geänderten Datei PFA_7segment.c:

<syntaxhighlight lang="c">

//
// Pollin Funk-AVR-Evaluationsboard
// PFA_7segment.c
//
// v 1.0
// v 1.1 - Pinbelegung geändert (s. Code)
// v 1.2 - Trennung in BCD-Version und Schieberegister-Version
// Pinbelegung s. Code
//
// PB0 => Spannungsversorgung Anzeige (über NPN Transistor)
// C: GND von der Anzeige
// B: PB0 => 2,2 K => B
// E: GND am PFA
// PD2 => Externer Taster2
// PD2 => Taster (offen) => 330Ω => GND

#include "PFA_7segment.h"
#include "PFA_funkhw.h"
#include <avr/delay.h>

#define BCD 0
#define SCHIEBEREGISTER !(BCD)

uint8_t led7segment_ziffern[ANZAHL_ZIFFERN];
static uint8_t led7segment_enabled = 0;

static void led7segment_power_off(void)
{
DDRB |= (1<<PB0);
PORTB &= ~(1<<PB0);
}

static void led7segment_power_on(void)
{
DDRB |= (1<<PB0);
PORTB |= (1<<PB0);
}

#if SCHIEBEREGISTER
/*
###################################
SCHIEBEREGISTER 74HC164
###################################
*/

#define SR_DDR DDRB
#define SR_PORT PORTB
#define SR_CLEAR PB2
#define SR_CLOCK PB5
#define SR_INPUT PB3

#define ZIFFERN_DDR DDRC
#define ZIFFERN_PORT PORTC
#define ZIFFER1 PC0
#define ZIFFER2 PC1
#define ZIFFER3 PC2
#define ZIFFER4 PC3

static uint8_t segment_tab[] =
{
// Quelle: AVR-Tutorial auf www.mikrocontroller.net
/* .db */ 0b11000000 , // ; 0: a, b, c, d, e, f
/* .db */ 0b11111001 , // ; 1: b, c
/* .db */ 0b10100100 , // ; 2: a, b, d, e, g
/* .db */ 0b10110000 , // ; 3: a, b, c, d, g
/* .db */ 0b10011001 , // ; 4: b, c, f, g
/* .db */ 0b10010010 , // ; 5: a, c, d, f, g
/* .db */ 0b10000010 , // ; 6: a, c, d, e, f, g
/* .db */ 0b11111000 , // ; 7: a, b, c
/* .db */ 0b10000000 , // ; 8: a, b, c, d, e, f, g
/* .db */ 0b10010000 , // ; 9: a, b, c, d, f, g
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF
};

void led7segment_init(void)
{
uint8_t i;

for (i = 0; i < ANZAHL_ZIFFERN; i++)
led7segment_ziffern[i] = 0b00001111; // BCD Blank

// Alle Ziffern aus
ZIFFERN_DDR |= ((1<<ZIFFER1) | (1<<ZIFFER2) | (1<<ZIFFER3) | (1<<ZIFFER4));
ZIFFERN_PORT |= ((1<<ZIFFER1) | (1<<ZIFFER2) | (1<<ZIFFER3) | (1<<ZIFFER4));

SR_DDR |= ((1<<SR_INPUT) | (1<<SR_CLOCK) | (1<<SR_CLEAR)); // Output
SR_PORT &= ~((1<<SR_INPUT) | (1<<SR_CLOCK) | (1<<SR_CLEAR)); // LOW

// Versorgungsspannung an
led7segment_power_on();

led7segment_enabled = 1;
}

void led7segment_exit(void)
{
SR_DDR &= ~((1<<SR_INPUT) | (1<<SR_CLOCK) | (1<<SR_CLEAR)); // Input
SR_PORT &= ~((1<<SR_INPUT) | (1<<SR_CLOCK) | (1<<SR_CLEAR)); // Pullups aus, Tristate

// RESET-Zustand: Pins Input und Tristate
ZIFFERN_DDR &= ~((1<<ZIFFER1) | (1<<ZIFFER2) | (1<<ZIFFER3) | (1<<ZIFFER4));
ZIFFERN_PORT &= ~((1<<ZIFFER1) | (1<<ZIFFER2) | (1<<ZIFFER3) | (1<<ZIFFER4));

// Versorgungsspannung aus
led7segment_power_off();

led7segment_enabled = 0;
}

void led7segment_multiplex(void)
{
static uint8_t ticks = 0;

if ( led7segment_enabled )
{
uint8_t tmp_segmente;
uint8_t i;

// Aktuelle Ziffer aus
switch ( ticks )
{
case 0:
ZIFFERN_PORT |= (1<<ZIFFER1);
break;
case 1:
ZIFFERN_PORT |= (1<<ZIFFER2);
break;
case 2:
ZIFFERN_PORT |= (1<<ZIFFER3);
break;
case 3:
ZIFFERN_PORT |= (1<<ZIFFER4);
break;
default:
break;
}

// Nächste Ziffer
ticks += 1;
ticks %= ANZAHL_ZIFFERN;
tmp_segmente = segment_tab[led7segment_ziffern[ticks] & 0x0F];

// Register leeren
SR_PORT = (1<<SR_CLOCK) | (0<<SR_CLEAR);
SR_PORT = (1<<SR_CLOCK) | (1<<SR_CLEAR);

i = 8;
do
{
i -= 1;
SR_PORT |= (1<<SR_INPUT);
SR_PORT &= ~(1<<SR_CLOCK);
if ( !(tmp_segmente & (1<<i)) ) // MSB zuerst
SR_PORT &= ~(1<<SR_INPUT);
SR_PORT |= (1<<SR_CLOCK);
}
while (i);

SR_PORT = (1<<SR_CLOCK) | (1<<SR_CLEAR) | (0<<SR_INPUT);

// Aktuelle Ziffer ein
switch ( ticks )
{
case 0:
ZIFFERN_PORT &= ~(1<<ZIFFER1);
break;
case 1:
ZIFFERN_PORT &= ~(1<<ZIFFER2);
break;
case 2:
ZIFFERN_PORT &= ~(1<<ZIFFER3);
break;
case 3:
ZIFFERN_PORT &= ~(1<<ZIFFER4);
break;
default:
break;
}
}
}
#endif /* SCHIEBEREGISTER */

#if BCD
/*
####################################
BCD-7Segment-Decoder CA3161
####################################
*/

void led7segment_init(void)
{
uint8_t i;

for (i = 0; i < ANZAHL_ZIFFERN; i++)
led7segment_ziffern[i] = 0b00001111; // BCD Blank

// Spannung aller Ziffern aus (neg. Logik)
DDRD |= (1<<PD0) | (1<<PD1) | (1<<PD2) | (1<<PD3);
PORTD |= (1<<PD0) | (1<<PD1) | (1<<PD2) | (1<<PD3);

// Versorgungsspannung an
led7segment_power_on();

// Alle Segmente der Ziffern aus
DDRC |= (1<<PC0) | (1<<PC1) | (1<<PC2) | (1<<PC3);
PORTC |= (1<<PC0) | (1<<PC1) | (1<<PC2) | (1<<PC3); // BCD Code 0b1111 für "Blank" an Ausgabepins

led7segment_enabled = 1;
}

void led7segment_exit(void)
{
uint8_t i;

for (i = 0; i < ANZAHL_ZIFFERN; i++)
led7segment_ziffern[i] = 0b00001111; // BCD Blank

// RESET-Zustand: Pins Input und Tristate
DDRD &= ~((1<<PD0) | (1<<PD1) | (1<<PD2) | (1<<PD3));
PORTD &= ~((1<<PD0) | (1<<PD1) | (1<<PD2) | (1<<PD3));

// RESET-Zustand: Pins Input und Tristate
DDRC &= ~((1<<PC0) | (1<<PC1) | (1<<PC2) | (1<<PC3));
PORTC &= ~((1<<PC0) | (1<<PC1) | (1<<PC2) | (1<<PC3));

// Versorgungsspannung aus
led7segment_power_off();

led7segment_enabled = 0;
}

void led7segment_multiplex(void)
{
static uint8_t ticks = 0;

if ( led7segment_enabled )
{
// Spannung aller Ziffern aus (neg. Logik)
PORTD |= (1<<PD0) | (1<<PD1) | (1<<PD2) | (1<<PD3);

// Segmente der neuen Ziffer berechnen
PORTC = (PORTC & 0b11110000) | led7segment_ziffern[ticks];
switch ( ticks )
{
case 0:
PORTD &= ~(1<<PD0); // Spannung ein
break;
case 1:
PORTD &= ~(1<<PD1);
break;
case 2:
PORTD &= ~(1<<PD2);
break;
case 3:
PORTD &= ~(1<<PD3);
break;
default:
break;
}

// auf nächste Ziffer weiterschalten
ticks += 1;
ticks %= ANZAHL_ZIFFERN;
}
}
#endif /* BCD */

// EOF PFA_7segment.c
</syntaxhighlight>

=== Timer1 Interrupt ===

F: Wie kann man den Timer 1 Compare Match Interrupt auslösen ([http://www.mikrocontroller.net/topic/124400])?

Hier ist ein Beispiel mit dem Timer1 im Modus ''PWM phase and frequency correct''. LED1 blinkt mit 1 Hz per Timer 1 Interrupt und LED2 mit 1 Hz per Software (_delay_ms()):

<syntaxhighlight lang="c">
/*
Pollin Funk AVR Evaluationsboard
F_CPU 12000000
MCU ATMega8
Compileoptionen -Os
*/

#ifndef F_CPU
#define F_CPU 12000000L
#endif

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

ISR (TIMER1_COMPA_vect)
{
PORTD ^= (1<<PD6); // toggle LED1
}

void Timer_io_init(void)
{
// Table 39 im Atmega8 Datenblatt
// Waveform generation mode:
// Mode 9: PWM Phase and frequency correct
TCCR1A |= (0 << WGM11) | (1 << WGM10);
TCCR1B |= (1 << WGM13) | (0 << WGM12);

// Table 40 im Atmega8 Datenblatt
// PRESCALER: clk/1024
TCCR1B |= (1 << CS12) | (0 << CS11) | (1 << CS10);

/*
Wunsch: ca. 1 Hz Blinken
1 Hz genau - siehe: http://www.mikrocontroller.net/articles/AVR_-_Die_genaue_Sekunde_/_RTC

Setzen von TOP (OCR1A) = Anzahl der Timer1-Takte von IRQ zu IRQ
Figure 40 im Atmega8 Datenblatt
1. /2 wegen 2 Halbperioden pro Sekunde bei 1 Hz
2. /2 wegen Runterzählen von TOP (=OCR1A) nach BOTTOM (=0)
und Hochzählen von BOTTOM (=0) bis TOP (=OCR1A) zwischen
den Interrupts
*/

#define DELAY (F_CPU / 1024 / 2 / 2)
OCR1A = DELAY;
TCNT1 = - DELAY; // Anlauf für 1. Interrupt verlängern

TIMSK = (1 << OCIE1A);
}

int main(void)
{
DDRD = (1<<PD6) | (1<<PD5);
Timer_io_init();
sei();
while(1)
{
PORTD ^= (1<<PD5); // toggle LED2
_delay_ms(500);
}
}
</syntaxhighlight>

=== RC5 Empfänger ===

Im Verlauf der Diskussion [http://www.mikrocontroller.net/topic/124288] stellte sich die Frage, wie ein Empfänger für den RC5 Code von Infrarot (IR) Fernbedienungen aufgebaut werden kann.

Vorab eine Anmerkung, die man auch regelmäßig im Forum liest: Nur relativ wenige IR-Fernbedienungen benutzen auch den von Philips erfundenen RC5 Code. Ich habe mir eine preiswerte Universalfernbedienung beschafft, die man auf Philips Geräte einstellen kann.

Der Aufbau des RC5-Codes und vieler anderer IR-Codes ist übrigens sehr gut auf der Seite von Sam Bergmans beschrieben ([http://www.sbprojects.com/knowledge/ir/ir.htm www.sbprojects.com]). Und der Eigenbau eines passenden Senders war ja die Ausgangslage in obiger Diskussion...

[[Bild:TSOP1736.png|thumb|right|240px|'''TSOP1736''' aus: Photo Modules for PCM Remote Control Systems von Vishay]]

Zum Empfang von RC5-kodierten IR-Signale ist der IR-Empfänger '''TSOP1736''' ([http://www.datasheetcatalog.org/datasheets/208/301092_DS.pdf PDF]) von Vishay geeignet.

Leider ist der TSOP1736 inzwischen abgekündigt. Es gibt aber funktionskompatiblen Ersatz [http://www.mikrocontroller.net/topic/198470#1946910] und [http://www.mikrocontroller.net/topic/200202#1966074]. Bei den Ersatztypen ist unbedingt die Pinbelegung anhand des Datenblattes zu kontrollieren und ggf. anzupassen.

In der Codesammlung hat '''Peter Dannegger''' C-Quelltexte veröffentlicht, die eine Dekodierung von RC5 Signalen auf AVR µCs ermöglichen ([http://www.mikrocontroller.net/topic/12216]). Bei einigen Compilerversionen muss die Rückgabevariable rc5_data '''volatile''' gekennzeichnet sein, wenn man mit Optimierung übersetzt ([http://www.mikrocontroller.net/topic/137340]).

Die Quelltexte werden wie üblich in ein AVR-Studio C Projekt aufgenommen. Unter den Projektoptionen wird die 8000000 bei der Taktrate und die Optimierungstufe -Os eingestellt. 8 MHz ist ja der an der kleinsten µC-Fassung zu verbauende Quarz.

Folgende Änderungen sind zur Anpassung an einen '''Attiny2313''' auf dem Pollin Funk AVR Board nötig bzw. hilfreich.

'''Änderungen in main.h''':
* Anpassen der Includes. Hier ist der Pfad um avr/ zu ergänzen und die veraltete signal.h wird auskommentiert.
<syntaxhighlight lang="c">
#include <avr/io.h>
#include <avr/interrupt.h>
// #include <signal.h>
</syntaxhighlight>
* Anpassen des Eingangspins für das Signal vom TSOP1736.
<syntaxhighlight lang="c">
#define xRC5 PD2 // IR input low active (statt PD7)
</syntaxhighlight>
* Anpassen der Taktrate. Der Attiny2313 wird auf dem werksmäßigen Pollin Funk AVR Board mit 8 MHz betrieben. Die Einstellung der externen Taktquelle mit den [[AVR Fuses]] ist ebenfalls nötig, wenn noch nicht geschehen! Tipps zu Anpassungen für noch geringere Taktraten gibt es in der Diskussion ab Beitrag [http://www.mikrocontroller.net/topic/164465#1569609] im Forum.
<syntaxhighlight lang="c">
//#define XTAL 11.0592e6
#define XTAL 8e6 // Attiny2313 auf Pollin Funk AVR Board
</syntaxhighlight>
* Sicherstellen, dass die Variable für den Datenaustausch zwischen Hauptprogramm und Timerroutine '''volatile''' deklariert ist.
<syntaxhighlight lang="c">
extern volatile uint rc5_data; // store result
</syntaxhighlight>

'''Änderungen in main.c''':
* Anpassen der Timer-Register. Die Benennung beim Attiny2313 ist anders als im Original
<syntaxhighlight lang="c">
// TCCR0 = 1<<CS02; //divide by 256 Original
TCCR0B = 1<<CS02; //divide by 256 Attiny2313
</syntaxhighlight>
* Anpassung der UART-Initialisierung an die Initialisierung des Attiny2313 (siehe andere Beispiele in diesem Artikel)
* Änderung der DEBUG-LED. Im Original wird PORTB zum Debuggen benutzt. Das wird auf die LED1 auf dem Board geändert.
<syntaxhighlight lang="c">
// Am Programmanfang einfügen
DDRD |= (1<<PD6); // PD6 Ausgang
PORTD |= (1<<PD6); // DEBUG-LED LED1 an
...
// Auskommentiert
// DDRB = i; // LED output
</syntaxhighlight>

'''Änderungen in rc5.c''':
* Sicherstellen, dass die Variable für den Datenaustausch zwischen Hauptprogramm und Timerroutine '''volatile''' definiert ist.
<syntaxhighlight lang="c">
volatile uint rc5_data; // store result
</syntaxhighlight>
* Einbau der DEBUG-LED. Dazu wird folgendes Codestück zwischen #if 1 und #endif ergänzt.
<syntaxhighlight lang="c">
if( !tmp || rc5_time > PULSE_1_2 )
{ // start or long pulse time
#if 1
/*
Anschluss PD6----###--->|---- GND
*/
DDRD |= (1<<PD6); // PD6 auf Ausgang
PORTD ^= (1<<PD6); // LED1 an PD6 togglen
#endif
if( !(tmp & 0x4000) ) // not to many bits
</syntaxhighlight>

Der TSOP1736 OUT wird - wie in main.h definiert - an PD2 des Attiny2313 angeschlossen. PD2, Vcc und GND können von der 40-poligen Erweiterungsbuchse abgegriffen werden. In meinem Steckbrettaufbau hatte ich den 10 kOhm Pullup-Widerstand **) eingebaut aber die Entstörung der Betriebsspannung *) nicht. Bei einem "echten" Gerät würde ich beide Schaltungsoptionen einbauen.

[[Bild:Schema IR-RX.png]]

Die Ausgabe des dekodierten Signals (Togglebit Anm.[http://www.mikrocontroller.net/topic/168346#1613187], Adresse, Kommando) kann mit einem [[RS232]] Terminalprogramm betrachtet werden, Anschluss des Pollin Boards an die serielle Schnittstelle vorausgesetzt. Die RS232-Einstellungen sind 19200 Baud, 8 Batenbits, No Parity und 1 Stopbit.

Im Forumsbeitrag [http://www.mikrocontroller.net/topic/168346#1613115] stellt Alex
seine Erweiterung dieser RC5-Routine vor, mit der eine Fallunterscheidung kurzer/langer Tastendruck möglich ist. Damit realisiert Alex auf einer Taste eine EIN/AUS-Funktion (kurzer Tastendruck) und eine DIMMEN-Funktion (langer Tastendruck).

=== Klickidiklacki ===

In der Diskussion [http://www.mikrocontroller.net/topic/160416#1526039] ist die Frage aufgetaucht, wie man die '''Compare Output Unit''' verwenden kann. Das dort angegebene Beispiel, die seltsame Simulation im AVR Studio und die Diskussion haben mich dazu geführt, folgendes Beispiel mit dem Attiny2313 zu erstellen.

Das Programm ist komplett abgespeckt: Der Taster1 wirkt über eine Brücke Pin 10 nach Pin 30 an J4 als externer Taktgeber an Pin T0. Wenn die Anzahl der Tastendrücke gleich dem vorgegehenen Wert 5 in Register OCR0A ist, wird der Ausgang OC0A automatisch umgeschaltet. Da der Ausgang OC0A über eine Brücke an J4 mit der LED1 verbunden ist, wird die LED umgeschaltet.

Die Besonderheit: Alles funktioniert automatisch per Hardware. Zu Programmbeginn wird einmal die Hardware eingestellt, und sie läuft dann autonom parallel zur Software. Die Software ist in diesem Fall eine leere Endlosschleife.

<syntaxhighlight lang="c">
/*
Beispiel: Compare Output Unit

Pollin Funk AVR Board
Attiny2313 @ 8 MHz

Attiny2313 J4
Taster1 active-high PB1 Pin 10 --+
LED1 active-high PD5 Pin 31 --+ |
| | Brücke
T0 PD4 Pin 30 | --+
OC0B PD5 Pin 31 |
OC0A PB2 Pin 11 --+
*/

#include <avr/io.h>

int main(void)
{
DDRB |= (1<<PB2); // PB2 Ausgang OC0A

//
// Compare Output Unit einstellen. S 74
//
// Vergleichswert
OCR0A = 5 - 1; // 5x Taster drücken
// Toggle OC0A bei TCNT0 == OCR0A
TCCR0A |= (0 << COM0A1) | (1 << COM0A0);
// CTC Mode
TCCR0A |= (1 << WGM01) | (0 << WGM00);
// Externe Clock an T0 bei steigender Flanke (Taster schliesst)
TCCR0B |= (1 << CS00) | (1 << CS01) | (1 << CS02);

while (1)
{
}

return 0;
}

</syntaxhighlight>

Der '''CTC-Modus''' bewirkt, dass beim zutreffenden Vergleich (TCNT0 == OCR0A) TCNT0 automatisch wieder auf 0 gesetzt wird. Leider kann dieser Modus mit dem anderen Ausgang OC0B nicht realisiert werden; es hätte sich in diesem Fall gerade angeboten, weil PD5 und OC0B bereits auf dem gleichen Pin liegen (Pin 31 an J4). Ohne den CTC-Modus für OC0B müsste man selbst beim Vergleich TCNT0 per Software zurücksetzen.

Und bitte noch beachten: Es ist nur die seltsame Hardwareentprellung des Pollin-Boards vorhanden. Also nicht wundern, wenn die Zählerei mit dem Taster unzuverlässig ist. Wenn man jedoch eine nichtprellende Taktquelle an T0 benutzt, könnte man das Programm benutzen, um eine ankommende Frequenz z. B. hier durch 5 zu teilen (Bsp. 10 Hz auf 2 Hz runterteilen).

=== AVR-GCC-Tutorial/Die Timer und Zähler des AVR ===

Im folgenden ist das '''Beispiel für Compare Match Mode''' aus dem [[AVR-GCC-Tutorial/Die Timer und Zähler des AVR]] vom Atmega8 auf den Attiny2313 umgeschrieben. Die wesentlichen Änderungen sind mit ### markiert.

<syntaxhighlight lang="c">

/*
Anpassung des Timer-Beispiels aus dem AVR-GCC-Tutorial
an den Attiny2313 @ 8MHz auf dem Pollin Funk AVR Board

Erweiterung: (Lauf-)Zeitausgabe über UART 9600/8N1
*/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>

//Variablen für die Zeit
volatile unsigned int millisekunden=0;
volatile unsigned int sekunde=0;
volatile unsigned int minute=0;
volatile unsigned int stunde=0;

void uart_init(void)
{
// 9600 Baud bei F_CPU 8 MHz: (Baudratenfehler = +0,2%)
UBRRH = (uint8_t) ((F_CPU / (16 * 9600L) - 1) >> 8);
UBRRL = (uint8_t) (F_CPU / (16 * 9600L) - 1);

// Empfangen, Senden erlauben
UCSRB = (1<<RXEN) | (1<<TXEN);

// Frame Format: 8 Bits, No Parity, 1 Stopbit
UCSRC = ((1<<UCSZ1) | (1<<UCSZ0)) | ((0<<UPM1) | (0<<UPM0)) | (0<<USBS);
}

int uart_putchar( char c )
{
if( c == '\n' )
uart_putchar( '\r' );

loop_until_bit_is_set( UCSRA, UDRE );
UDR = c;
return 0;
}

void uart_puts(char *s)
{
while(*s)
uart_putchar(*s++);
}

void zeitausgabe(void)
{
static char last_sekunde = 255;
char buffer[4];

if ((last_sekunde != sekunde))
{
last_sekunde = sekunde;
itoa(stunde+100, buffer,10);
uart_puts(buffer+1);
uart_puts(":");
itoa(minute+100, buffer,10);
uart_puts(buffer+1);
uart_puts(":");
itoa(sekunde+100, buffer,10);
uart_puts(buffer+1);
uart_puts("\r\n");
}
}

int main(void)
{
uart_init();

//Timer 0 konfigurieren auf CTC-Modus Attiny2313
TCCR0A = (1<<WGM01); // ###
TCCR0B = (1<<CS01) | (1<<CS00); // ### Prescaler 8*8 = 64 bei 8 MHz
OCR0A=125-1; // ### Bugfix 20091221

//Compare Interrupt aktivieren
TIMSK|=(1<<OCIE0A); // ###

//Globale Interrupts aktivieren
sei();

while(1)
{
/*Hier kann die aktuelle Zeit ausgeben werden*/
zeitausgabe();
}

return 0;
}

// Der Compare Interrupt Handler
// Wird aufgerufen wenn TCNT0 = 125
ISR (TIMER0_COMPA_vect) // ###
{
millisekunden++;
if(millisekunden==1000)
{
sekunde++;
millisekunden=0;
if(sekunde==60)
{
minute++;
sekunde=0;
}
if(minute ==60)
{
stunde++;
minute=0;
}
}
}

</syntaxhighlight>

Der Bequemlichkeit halber ist eine (Lauf-)Zeitanzeige per UART (9600 Baud 8 Datenbits, 1 Stoppbit, keine Parität) hinzugefügt: So lässt sich das Programm als sekunden<strike>genaue</strike>aufgelöste Stoppuhr benutzen (RESET-Taster = Neustart).

Noch ein Nachtrag zu diesem Beispiel:

Die ISR und das Anwendungsprogramm (genauer die Routine ''zeitausgabe()'') benutzen gemeinsame Variablen, die auch korrekt als '''volatile''' gekennzeichnet sind.

Dennoch versteckt in diesem Programm ein potenzieller Bug: Der Datenzugriff ist nicht '''atomar'''! Der Bug macht sich bloß nicht bemerkbar, weil die ''zeitausgabe'' weit weniger als eine Sekunde braucht, um die Daten auszugeben.

Angenommen ''zeitausgabe()'' braucht länger, was könnte passieren? Die gemeinsamen Variablen vom Typ unsigned int sind größer 1 Byte bzw. der kompletten Zeitstempel ''stunde:minute:sekunde'' ist wesentlich größer als 1 Byte. Eine Leseoperation bzw. die Ausgabe benötigt also '''mehrere''' Maschinenanweisungen bzw. sogar C-Anweisungen. Ein Interrupt könnte diese Anweisugen z. B. der beiden Bytes von unsigned int ''sekunde'' unterbrechen und ggf. das noch nicht gelesene Byte ändern. Oder ''minute'' sei bereits über UART ausgegeben, dann vor der Ausgabe von ''sekunde'' unterbricht der Timer und erhöht ''sekunde''. Wenn ''sekunde'' bereits 59 war, wird ''minute'' erhöht und sekunde auf 0 gesetzt. ''minute'' war aber bereits ausgegeben... die Anzeige ist dann falsch!

Als Ausweg bietet die avr-libc Hilfsmittel zur Sicherstellung des atomaren Datenzugriffes. Mit Hilfe des Makros ATOMIC_BLOCK können Interrupts gesperrt werden, wenn die Anweisungen im {}-Block ausgeführt werden.

<syntaxhighlight lang="c">
#include <util/atomic.h>

void zeitausgabe(void)
{
static char last_sekunde = 255;
char buffer[4];
unsigned int tmp_stunde;
unsigned int tmp_minute;
unsigned int tmp_sekunde;

// Übersetzung mit der Compileroption
// -std=c99 oder -std=gnu99 erforderlich
ATOMIC_BLOCK(ATOMIC_FORCEON)
{
// Schnappschuss anfertigen
// Timerinterrupt ist gesperrt!
// Diese Anweisungen knapp halten!
tmp_stunde = stunde;
tmp_minute = minute;
tmp_sekunde = sekunde;
}

// Schnappschuss aufarbeiten
if ((last_sekunde != tmp_sekunde))
{
last_sekunde = tmp_sekunde;
itoa(tmp_stunde+100, buffer,10);
uart_puts(buffer+1);
uart_puts(":");
itoa(tmp_minute+100, buffer,10);
uart_puts(buffer+1);
uart_puts(":");
itoa(tmp_sekunde+100, buffer,10);
uart_puts(buffer+1);
uart_puts("\r\n");
}
}
</syntaxhighlight>

Weiteres kann man dazu im Artikel [[Interrupt]] und [[AVR-GCC-Tutorial#Variablen_gr.C3.B6.C3.9Fer_1_Byte| AVR-GCC-Tutorial - Variablen größer 1 Byte]] und in der Dokumentation der avr-libc nachlesen.

=== "Scotty, Handbremse!" ===

Die Frage in [http://www.mikrocontroller.net/topic/164079#1565907] hat mich neugierig gemacht, wie das '''Clock Prescale Register CLKPR''' arbeitet. Achtung: Bei großen Clock Prescale Werten vorher unbedingt [http://www.mikrocontroller.net/articles/AVR_Fuses#Reaktivieren_beim_CLKPR-Problem_.28Attiny13.29 dies] lesen.

Im AVR Studio (4.12 SP2) konnte im Originalprogramm beim ATtiny13 als auch später beim ATtiny2313 in der Simulation (Debugger) kein Unterschied festgestellt werden egal ob mit oder ohne '''Clock Division Factor''' simuliert wurde.

Daraufhin wurde das Originalprogramm auf das Pollin Funk AVR Board "angepasst", d.h. LED1 und LED2 blinken wechselweise und der Taster dient als Eingabe:
* Taster loslassen und RESET ausführen, und das Programm arbeitet ohne Clock Division Factor
* Taster gedrückt halten und RESET ausführen, und das Programm arbeitet mit Clock Division Factor. Sobald die LEDs blinken, kann der Taster losgelassen werden.

<syntaxhighlight lang="avrasm">
; http://www.mikrocontroller.net/topic/164079#1565907
; Blink2.asm Blinker mit Unterprogramm (aus Franzis Lernpaket)
; modifiziert 20100122 für Attiny2313 @ 8 MHz auf Pollin Funk AVR Hardware

.include "tn2313def.inc"

.org 0x0000
rjmp Anfang

Anfang:
; Stack einrichten weil rcall/ret verwendet wird
; Nicht nötig bei ATtiny13 (Originalcode)
; Aber nötig bei ATtiny2313
ldi r16,LOW(RAMEND)
out SPL,r16

; Speed Divider Set
IN r16,PINB
SBRC r16,PINB1 ; Taster losgelassen => kein Nurhalbekraft
rcall Nurhalbekraft

; Ports initialisieren
ldi r16,((1<<PORTD6)|(1<<PORTD5))
out DDRD,r16 ; als Ausgang einrichten, Rest Eingang

; Endlose Arbeitsschleife: Wechselbinkler mit LED1 und LED2
L_Schleife:
ldi r16,(1<<PORTD5)
out PORTD,r16
rcall Warten
ldi r16,(1<<PORTD6)
out PORTD,r16
rcall Warten
rjmp L_Schleife

; Hilfsroutinen

; Speed Divider Set
Nurhalbekraft:
in r17, SREG ; Statusregister in Hilfsregister retten
cli ; Global Interrupts disablen
ldi r16,(1<<CLKPCE) ; 1, Clock Prescaler Change Enable
out CLKPR,r16 ; 1, Clock Prescale Register "öffnen"
ldi r16,(1<<CLKPS0) ; 1, Sollwert Clock Division Factor 2
out CLKPR,r16 ; 1, Clock Prescale Register "beschreiben"
; max. 4 Takte Regel ist eingehalten.
out SREG, r17 ; Statusregister aus Hilfsregister restaurieren
ret ; zurück zum Aufrufer (rcall)

; Warten
; ca. 150ms bei 8 MHz
Warten:
Ldi r18,8*10
L0_Warten:
Ldi r16,20
L1_Warten: ;äußere Schleife
Ldi r17,250
L2_Warten: ;innere Schleife
dec r17
brne L2_Warten
dec r16
brne L1_Warten
dec r18
brne L0_Warten
ret
</syntaxhighlight>

Ergebnis: Der Clock Division Factor ist auf der Hardware aktiv bzw. der Simulator (bei meinem AVR Studio) ist fehlerhaft. Probieren geht über Studieren (Simulieren) :)

=== Tasty Reloaded ===

Peter Dannegger hat in [http://www.mikrocontroller.net/topic/164194#1566921 "Entprellen für Anfänger"] eine neue vereinfachte Entprellroutine vorgestellt. Hier ein Minimalbeispiel in dem dieses Verfahren verwendet wird:

<syntaxhighlight lang="c">
// Target: Attiny2313 @ 8 MHz Pollin Funk AVR Board

#include <avr/io.h>

#ifndef F_CPU
#define F_CPU 8e6 // ###
#endif
#include <util/delay.h>

/****************************************************/
/* */
/* Not so powerful Debouncing Macro */
/* No Interrupt needed */
/* */
/* Author: Peter Dannegger */
/* */
/****************************************************/

// Modification for active high push button

#define debounce( port, pin ) \
({ \
static uint8_t flag = 0; /* new variable on every macro usage */ \
uint8_t i = 0; \
\
if( flag ){ /* check for key release: */ \
for(;;){ /* loop... */ \
if( (port & 1<<pin) ){ /* ... until key pressed or ... */ \
i = 0; /* 0 = bounce */ \
break; \
} \
_delay_us( 98 ); /* * 256 = 25ms */ \
if( --i == 0 ){ /* ... until key >25ms released */ \
flag = 0; /* clear press flag */ \
i = 0; /* 0 = key release debounced */ \
break; \
} \
} \
}else{ /* else check for key press: */ \
for(;;){ /* loop ... */ \
if( !(port & 1<<pin) ){ /* ... until key released or ... */ \
i = 0; /* 0 = bounce */ \
break; \
} \
_delay_us( 98 ); /* * 256 = 25ms */ \
if( --i == 0 ){ /* ... until key >25ms pressed */ \
flag = 1; /* set press flag */ \
i = 1; /* 1 = key press debounced */ \
break; \
} \
} \
} \
i; /* return value of Macro */ \
})

/*
Debouncing Example
*/

int main(void)
{
// push button @ PB1 in active high configuration
DDRB &= ~(1<<PB1);
// PORTB |= 1<<PB1; // not needed because active high

// LED @ PD5 in active high configuration
DDRD |= 1<<PD5;

for(;;){
if( debounce( PINB, PB1 ) )
PORTD ^= 1<<PD5; // Toggle LED
}
}
</syntaxhighlight>

Der Codebedarf für die debounce()-Teilfunktion liegt bei meinem System bei nur 54 Bytes und der SRAM Bedarf bei 1 Byte (WinAVR-20071221, -Os).

Peter schreibt: ''"Man kann sogar das Programm so ändern, daß beide Flanken zurückgegeben werden (als 1 bzw. 2), dazu muß nur eine Zuweisung auf "i = 2;" geändert werden."''

Die Änderung betrifft diesen Teil, bei dem statt

<syntaxhighlight lang="c">
i = 0; /* 0 = key release debounced */ \
</syntaxhighlight>

zu schreiben wäre:

<syntaxhighlight lang="c">
i = 2; /* 2 = key release debounced */ \
</syntaxhighlight>

Dann schaltet im Beispiel die LED beim Drücken und Loslassen um!

=== Blinky Reloaded ===

Die Frage von Markus und die Grundroutine in [http://www.mikrocontroller.net/topic/165543#1581129] zum Tutorial [[LED-Fading]] von Falk bringt mich dazu, das mit dem Attiny2313 auch mal zu probieren.

Im folgenden Quelltext werden die LED1 und LED2 des Pollinboards langsam und wechselseitig auf- und abgeblendet. Damit die 8-Bit PWM Signale zu den LED gelangen können, wird eine Drahtbrücke zwischen Pin 12 und Pin 32 an der 40-poligen Jumperleiste J4 angebracht.

<syntaxhighlight lang="c">
#include <avr/io.h>
#include <util/delay.h>

/*
F_CPU = 8 MHz
Compileroption -Os

Attiny2313 POLLIN FUNK AVR BRÜCKE
=======================================
PB2 OC0A 11 an J4
PD5 OC0B PD5/LED2 31 an J4
PB3 OC1A 12 an J4 --+
PB4 OC1B 13 an J4 |
PD6/LED1 32 an J4 --+
*/

#if 0
// Beispiel mit linearem Verlauf der PWM Werte
unsigned char pwmtable_8D[32] = {
0*8, 1*8, 2*8, 3*8, 4*8, 5*8, 6*8, 7*8,
8*8, 9*8, 10*8, 11*8, 12*8, 13*8, 14*8, 15*8,
16*8, 17*8, 18*8, 19*8, 20*8, 21*8, 22*8, 23*8,
24*8, 25*8, 26*8, 27*8, 28*8, 29*8, 30*8, 31*8
};
#endif

// Beispiel mit nichtlinearem Verlauf der PWM Werte
unsigned char pwmtable_8D[32] = {
0, 1, 2, 2, 2, 3, 3, 4, 5, 6, 7, 8, 10, 11,
13, 16, 19, 23, 27, 32, 38, 45, 54, 64, 76,
91, 108, 128, 152, 181, 215, 255
};

void init_fade(void)
{
DDRB = (1<<PB2) | (1<<PB3) | (1<<PB4);
DDRD = (1<<PD5);

// 8-Bit Timer0
// Clear OC0A/OC0B on compare-match when up counting
// Set OC0A/OC0B on compare-match on TOP
TCCR0A = (1<<COM0A1) | (1<<COM0B1) | (1<<WGM01) | (1<<WGM00); // 0xA3 Mode 3 Fast-PWM TOP=0xFF
TCCR0B = (1<<CS02); // precaler 256 -> ~122 Hz PWM frequency

// 16-Bit Timer1
// Clear OC0A/OC0B on compare-match
// Set OC0A/OC0B on compare-match on TOP (=0xFF)
TCCR1A = (1<<COM1A1) | (1<<COM1B1) | (1<<WGM10); // // 0xA1
TCCR1B = (1<<WGM12); // 0x08 Mode 5 non-inverted PWM on OC1A, 8 Bit Fast PWM
TCCR1B |= (1<<CS02); // precaler 256 -> ~122 Hz PWM frequency
}

void fade(void)
{
unsigned char tmp;

for(tmp=0; tmp<=31; tmp++){
OCR0B = *(pwmtable_8D+31-tmp); // LED2 ausfaden
OCR1A = *(pwmtable_8D+tmp); // gleichzeitig LED1 einfaden
_delay_ms(50);
}

_delay_ms(1000);

for(tmp=0; tmp<=31; tmp++){
OCR0B = *(pwmtable_8D+tmp); //LED2 wieder einfaden
OCR1A = *(pwmtable_8D+31-tmp); //LED1 ausfaden
_delay_ms(50);
}

_delay_ms(1000);
}

int main(void)
{
init_fade();

while(1)
{
fade();
}
}

</syntaxhighlight>

Aufgepasst? Im Quelltext sind pro Timer '''zwei''' PWMs aktiviert, aber nur je eine wird für LED1 und LED2 benutzt. Die doppelte Aktivierung ist natürlich nicht notwendig, sondern das ist eine Vorschau auf später, weil Markus sein Programm auf vier LEDs erweitern will.

=== "Dreh' am Rad" ===

Seltsamerweise boomen derzeit (2/2010) die [[ADC]]-Themen im Forum. Da konnte ich mich nicht zurückhalten. Das muss ich auch probieren und bin wieder zurück auf den '''Atmega8''' gewechselt, weil der Attiny2313 keinen ADC besitzt.

Für dieses ADC Beispiel braucht man einen verstellbaren Widerstand ([http://de.wikipedia.org/wiki/Potentiometer Potentiometer (Wikipedia)]). Dessen Schleiferbahn wird zwischen der Versorgungsspannung Vcc und GND angeschlossen. Der Schleifkontakt wird mit ADC2 (PC2) am Atmega8 verbunden. Das Potentiometer wirkt damit als [[Spannungsteiler]], wobei R1+R2 aus dem Artikel der Gesamtwiderstand des Potentiometers sind und die Stellung des Schleifkontakts die Widerstände R1 und R2 verändert. Ich habe ein 10K lineares Potentiometer aus der Bastelkiste benutzt.

Im Programm wird die Ausgangsspannung des Spannungsteilers gegen die Referenzspannung AVcc gemessen und als 10-Bit ADC-Wert digitalisiert (angepasste Funktion ReadChannel() aus dem [[AVR-GCC-Tutorial]]).

Als Schmankerl wird der ADC-Wert auch benutzt, um einen Stufenschalter nachzubilden. Diese Anregung habe ich beim Stöbern im Zeitschriftenladen bekommen. In der Zeitschrift ''Funkamateur'' 2/2010 beschreibt ''DH1LD'' sein Projekt "Virtueller Stufenschalter für den Mikrocontroller", geschrieben in BASCOM-AVR.

Als Anzeige gibt es eine einfache Hardwareanzeige: Die LED2 blinkt umgekehrt proportional zum ADC-Wert (kleiner Wert = schnellstes Blinken). Und es gibt zwei Optionen für die UART-Anzeige an einem Terminal (9600/8N1 Einstellung): Eine Ziffernanzeige und eine "billige" Balkenanzeige.

Das Projekt besteht aus den folgenden drei Quelltexten. Die UART-Routinen wurden bereits beim Zähler mit RS232 benutzt.

Datei '''PFA_ADC_10K.c'''
<syntaxhighlight lang="c">
/*
ADC-Beispiel

Pollin Funk AVR Board
Atmega8 @ 12 MHz

Boardeigene Hardware
====================
LED2
UART 9600/8N1

Zusätzliche Hardware:
====================
ca. 10K lineares Potentiometer
Schleiferbahn zwischen Vcc und GND
Schleiferkontakt zu ADC2 (= PC2)

Bugfix 20100212
*/

#include <avr/io.h>
#include <stdlib.h> // utoa()
#include <string.h> // strlen()
#include "PFA_uart_m8.h"

/*
ADC
Single Conversion Modus
Vref == AVcc
für F_CPU 12 MHz angepasst
Arithm. Mittelwert aus 4 Einzelmessung
*/
uint16_t ReadChannel(uint8_t mux)
{
uint16_t result;
uint8_t i;

mux |= (1<<REFS0); // AVCC als Referenz ###
ADMUX = mux; // Referenz und Kanal setzen ###

/*
Frequenzvorteiler setzen und ADC enablen

ADC soll optimal mit 50 kHz bis 200 kHz laufen
12000000/200000 = 60
12000000/50000 = 240
=> Vorteiler
64 (1<<ADPS2) | (1<<ADPS1)
128 (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0)
*/
ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1); // ###

/*
Nach dem Wechsel der ADC Referenz (oder dem Wechsel eines
differentiellen Kanals) wird ein "Dummy-Readout" empfohlen.
Man ermittelt also einen ungenauen ADC Wert und verwirft diesen.

Auch wenn es sich hier um eine Dummy_ADC_Wandlung handelt, muss
das ADCW Register anschliessend gelesen werden, sonst wird das
Ergebnis der eigentlichen Messung (s.u.) nicht übernommen!
*/
ADCSRA |= (1<<ADSC); // eine Wandlung "single conversion" auslösen
while ( ADCSRA & (1<<ADSC) )
{
; // auf den Abschluss der Konvertierung warten
}
result = ADCW;

/*
Eigentliche Messung
Mittelwert aus 4 aufeinanderfolgenden Wandlungen
*/
result = 0;
for( i=0; i<4; i++ )
{
ADCSRA |= (1<<ADSC); // eine Wandlung "single conversion" auslösen
while ( ADCSRA & (1<<ADSC) )
{
; // auf den Abschluss der Konvertierung warten
}
result += ADCW; // Wandlungsergebnisse aufaddieren
}
ADCSRA &= ~(1<<ADEN); // ADC disablen (spart Strom)
result /= 4; // arithm. Mittelwert bilden
return result;
}

/*
Stufenschalter für ADC Werte

Inspiriert durch:
DH1LD
"Virtueller Stufenschalter für den Mikrocontroller"
BASCOM-AVR Routine
Funkamateur 2/2009
*/
#define MESSBEREICH 1024 /* 0..1023 */
#define STUFENZAHL 11 /* 1..STUFENZAHL :) */
#define HYSTERESE (5*(MESSBEREICH/STUFENZAHL)/100) /* ca. 5% */
#define STUFE(a) ((STUFENZAHL*(a)+MESSBEREICH)/MESSBEREICH)

uint8_t stufenschalter(uint16_t adcw)
{
static uint8_t last_s = 0;
uint8_t tmp_s = 0;

// Vorläufige Stufe berechnen
tmp_s = STUFE(adcw);

// Korrektur für Hysterese
if ((tmp_s-last_s == 1) && (adcw > HYSTERESE))
{
tmp_s = STUFE(adcw - HYSTERESE);
}
else if ((tmp_s-last_s == -1) && (adcw < MESSBEREICH-HYSTERESE))
{
tmp_s = STUFE(adcw + HYSTERESE);
}

last_s = tmp_s;
return last_s;
}

/*
Zahlenwerte über UART ausgeben
Leichte Pufferung um die Ausgabemenge rel. klein zu halten
*/
void werte_anzeigen(uint16_t adcval, uint8_t schalterpos)
{
static uint16_t last_adcval = 0xFFFF;
static uint8_t last_schalterpos = 0xFF;
uint8_t crlf = 0;
char buffer[5];
uint8_t i;

if (last_adcval != adcval)
{
// Neuen ADC-Wert mit vier Stellen ausgeben
last_adcval = adcval;
UART_puts("ADC=[");
utoa(adcval, buffer, 10);
for (i=4-strlen(buffer); i; i--)
UART_putchar(' ');
UART_puts(buffer);
UART_putchar(']');
crlf = 1;
}

if (last_schalterpos != schalterpos)
{
// Neue Schalterposition mit zwei Stellen ausgeben
last_schalterpos = schalterpos;
UART_puts(" Schalter=[");
utoa(schalterpos, buffer, 10);
for (i=2-strlen(buffer); i; i--)
UART_putchar(' ');
UART_puts(buffer);
UART_putchar(']');
crlf = 1;
}

if (crlf)
UART_puts("\r\n");
}

/*
Schalterposition als horiz. Balken
über UART ausgeben
*/
void balkenanzeige(uint8_t schalterpos)
{
static uint8_t last_schalterpos = 0xFF;
uint8_t i;

if ( last_schalterpos != schalterpos )
{
UART_puts("\r|");
for(i=0; i<schalterpos; i++)
UART_puts("###|");
for(i=schalterpos; i<STUFENZAHL; i++)
UART_puts("---|");
last_schalterpos = schalterpos;
UART_putchar('\r');
}

}

int main(void)
{
uint16_t adcval;
uint8_t schalterpos;
uint16_t i;

UART_init();
UART_putchar('\014'); // FORMFEED
UART_puts("PFA ADC Beispiel\r\n\r\n");

DDRD = (1<<PD5); // PD5 Ausgang für LED2

for(i=0;;i++)
{
adcval = ReadChannel(2);
schalterpos = stufenschalter(adcval);

#if 0
/* UART-Anzeige Option 1 */
werte_anzeigen(adcval, schalterpos);
#else
/* UART-Anzeige Option 2 */
balkenanzeige(schalterpos);
#endif

/*
LED2 blinken lassen
Blinkfrequenz umgekehrt proportional zum ADC-Wert
*/
if (i >= adcval)
{
i = 0;
PORTD ^= (1<<PD5); // Toggle LED2 mit XOR
}
}
}
</syntaxhighlight>

Datei '''PFA_uart_m8.c'''
<syntaxhighlight lang="c">
/*
UART-Routinen für Pollin Funk AVR Board
Atmega8 @ 12 MHz

9600/8N1
*/

#include "PFA_uart_m8.h"

void UART_init(void)
{
// Bausrate setzen
UBRRH = (uint8_t) ((F_CPU / (16 * BAUD) - 1) >> 8);
UBRRL = (uint8_t) (F_CPU / (16 * BAUD) - 1);

// Empfangen, Senden erlauben
UCSRB = (1<<RXEN) | (1<<TXEN);

// Frame Format: 8 Bits, No Parity, 1 Stopbit
UCSRC = (1<<URSEL) | ((1<<UCSZ1) | (1<<UCSZ0)) | ((0<<UPM1) | (0<<UPM0)) | (0<<USBS);
}

// Auf Zeichen im UART Eingang prüfen
uint8_t UART_peekchar(void)
{
// sofort zurückkehren und Zustand melden
return UCSRA & (1<<RXC);
}

// Auf Zeichen im UART Eingang warten
uint8_t UART_getchar(void)
{
// Warte bis UART Eingang voll
while ( !(UCSRA & (1<<RXC)) )
;
return UDR;
}

// Zeichen in UART Ausgang geben
void UART_putchar(char z)
{
// Warte bis UART Ausgang frei
while ( !(UCSRA & (1<<UDRE)) )
;
UDR = z;
}

// Zeichenkette (String) in UART Ausgang geben
void UART_puts(char *s)
{
while ( *s )
{
UART_putchar(*s);
s++;
}
}
</syntaxhighlight>

Datei '''PFA_uart_m8.h'''
<syntaxhighlight lang="c">
/*
UART-Routinen für Pollin Funk AVR Board
Atmega8 @ 12 MHz

9600/8N1
*/

#ifndef PFA_UART_M8_H
#define PFA_UART_M8_H

#include <avr/io.h>

// 9600 Baud bei F_CPU 12 MHz => Baudratenfehler = +0,2%
#define BAUD 9600L

void UART_init(void);

// Auf Zeichen im UART Eingang prüfen
uint8_t UART_peekchar(void);

// Auf Zeichen im UART Eingang warten
uint8_t UART_getchar(void);

// Zeichen in UART Ausgang geben
void UART_putchar(char z);

// Zeichenkette (String) in UART Ausgang geben
void UART_puts(char *s);

#endif /* PFA_UART_M8_H */
</syntaxhighlight>

=== Die Versorgung muss stimmen ===

Mit dem ADC kann man auch ohne zusätzliche Schaltung eine unbekannte bzw. im einfachen Batteriebetrieb fallende Versorgungsspannung Vcc (AVcc) messen, Dazu wird die zumessende Versorgungsspannung Vcc als Referenz Aref des ADC eingestellt und damit wird die bekannte Spannung der internen Bandgapreferenz Vbg gemessen. Dann wird gerechnet...

<syntaxhighlight lang="c">
/*
ADC-Beispiel #2:
Messung der Vcc mit Hilfe der internen Bandgap-Refernez

Pollin Fun AVR Board
Atmega8 @ 12 MHz

Boardeigene Hardware
====================
UART 9600/8N1

Zusätzliche Hardware:
====================
-
*/

#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h> // utoa()
#include <string.h> // strlen()
#include "PFA_uart_m8.h"

#define NUM_DUMMY_ADC 8
#define NUM_MESS_ADC 256 // max. 64 wenn uint16_t adcval
#define V_BANDGAP 1300UL // Atmega8

uint16_t vcc_messung(void)
{
uint32_t adcval;
uint16_t i;

/*
Aref : AVcc
Input: Interne 1.3V Bandgap-Referenz
*/
ADMUX = (1<<REFS0)|(1<<MUX3)|(1<<MUX2)|(1<<MUX1);

/*
Frequenzvorteiler setzen und ADC enablen

ADC soll optimal mit 50 kHz bis 200 kHz laufen
12000000/200000 = 60
12000000/50000 = 240
=> Vorteiler
64 (1<<ADPS2) | (1<<ADPS1)
128 (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0)
*/
ADCSRA = (1<<ADEN)|(1<<ADPS2)|(1<<ADPS1);

/*
MEHRERE Dummymessungen?
http://www.mikrocontroller.net/topic/98469#853068

Experimentieren!
*/
for(i=0; i<NUM_DUMMY_ADC; i++)
{
ADCSRA |= (1<<ADSC);
while (ADCSRA&(1<<ADSC))
{
}
adcval = ADCW;
}

/*
Tatsächliche Messung:
Mittelwert aus NUM_MESS_ADC Messungen
*/
adcval = 0;
for(i=0; i<NUM_MESS_ADC; i++)
{
ADCSRA |= (1<<ADSC);
while (ADCSRA&(1<<ADSC))
{
}
adcval += ADCW;
}

ADCSRA &= ~(1<<ADEN); // ADC disable
return (adcval + NUM_MESS_ADC/2)/NUM_MESS_ADC;
}

/*
Zahlenwerte über UART ausgeben
Leichte Pufferung um die Ausgabemenge rel. klein zu halten
*/
void vcc_werte_anzeigen(uint16_t adcval, uint16_t vcc)
{
static uint16_t last_adcval = 0xFFFF;
static uint16_t last_vcc = 0xFF;
uint8_t crlf = 0;
char buffer[6];
uint8_t i;

if (last_adcval != adcval)
{
last_adcval = adcval;
UART_puts("ADC=[");
utoa(adcval, buffer, 10);
for (i=5-strlen(buffer); i; i--)
UART_putchar(' ');
UART_puts(buffer);
UART_putchar(']');
crlf = 1;
}

if (last_vcc != vcc)
{
last_vcc = vcc;
UART_puts(" Vcc=[");
utoa(vcc, buffer, 10);
for (i=5-strlen(buffer); i; i--)
UART_putchar(' ');
UART_puts(buffer);
UART_puts("] mV");
crlf = 1;
}

if (crlf)
UART_puts("\r\n");
}

int main(void)
{
uint16_t adcval;
uint16_t vcc;

UART_init();
UART_putchar('\014'); // FORMFEED
UART_puts("PFA ADC Vcc Messung\r\n\r\n");

while(1)
{
adcval = vcc_messung();
/*
Allgemeine ADC Gleichung (10-Bit):
V_mess = (V_ref * ADC_mess) / 1024

Einstellungen:
V_mess = V_Bandgap (bekannt!)
V_ref = Vcc (unbekannt!)
=>
Vcc = V_ref = (V_Bandgap * 1024) / ADC_mess
*/
if (adcval)
{
vcc = (V_BANDGAP * 1024) / adcval; // in mV
vcc_werte_anzeigen(adcval, vcc);
}
else
{
UART_puts("ADC Einstellungen kontrollieren (adcval=0)\r\n");
}
}
}
</syntaxhighlight>

=== Temperaturmessung mit DS1621 ===

[[Bild:PFA_TWI_DS1621.jpg|thumb|right|256px|Und es war Sommer... Nein, die riesige 7-Segmentanzeige ist nicht Teil dieses Beispiels :)]]

In diesem Beispiel soll die Zimmertemperatur regelmäßig gemessen werden und von einem Atmega8 über RS232 an einen PC mit Terminalprogramm übertragen werden.

Der [[Temperatursensor]] '''DS1621''' von Maxim kann über den I2C bzw. [[TWI]] Bus an AVR angeschlossen werden. Herz der Kommunikation mit dem Sensor ist die Bibliothek TWIMASTER von Peter Fleury (http://jump.to/fleury). Darin wird eine Hardware-TWI-Kommunikation abgewickelt.

Ich hoffe der "Schaltplan" mit den vier Strippen, den beiden Pull-Up-Widerständen und der Adresseinstellung ist verständlich. Melden, wenn das nicht klar ist. Als Pull-Up-Widerstände habe ich 2,2 KOhm genommen, weil diese gerade vorhanden waren und im empfohlenen Bereich (1-10 KOhm) lagen. Details zum I2C-Bus und dessen Hardware finden sich übrigens auf http://www.i2c-bus.org/i2c-primer/

<syntaxhighlight lang="c">
/*
(Hardware)-TWI Kommunikation mit DS1621

HARDWARE:
Pollin Funk-AVR-Evaluationsboard v1.1
Atmega8 @ 12 MHz (-Os)
Maxim DS1621 Temperaursensor mit I2C Interface

LIBRARY:
I2C master library using hardware TWI interface
Peter Fleury <pfleury@gmx.ch> http://jump.to/fleury
v 1.3 2005/07/02 11:14:21

AUSGABE:
UART 9600 Baud 8-N-1

SCHALTUNG:
Pin Pin Pin
Atmega8 J4 Funktion DS1621
=========================================
27 PC4 5 --- SDA ---- 1 -------------+
|
28 PC5 6 --- SCL ---- 2 ------+ |
| |
Tout 3 NC | |
| |
GND 35 --- GND ---- 4 ---+ | |
| # #
DS1621 | # Rpu1 # Rpu2
A2 5 ---+ # 2.2K # 2.2K
Geräteadresse | # #
A1 6 ---+ | |
Device = 0 | | |
A0 7 ---+ | |
| |
Vcc 36 --- Vcc ---- 8 ------+------+

http://www.i2c-bus.org/i2c-primer/
Rpu Pull-up resistance (a.k.a. I2C termination)
Rpu commonly ranges from 1 kOhm to 10 kOhm
*/

#include <avr/io.h>
#include <util/delay.h>
//#include "PFA_funkhw.h"
#include "PFA_uart.h" // hier Umdefinition von DEBUG_PRINT mögl.
#include "i2cmaster.h"

#define DS1621_A0 0
#define DS1621_A1 1
#define DS1621_A2 2
#define DS1621_DEVICE ((0<<DS1621_A2)|(0<<DS1621_A1)|(0<<DS1621_A0))
#define DS1621_ADDRESS (0x90 | DS1621_DEVICE)
#define MY_SDA PC4
#define MY_SCL PC5

void DS1621_init(void)
{
DEBUG_PRINT("DS1621_init:\r\n");
DEBUG_PRINT("vor i2c_init\r\n");
i2c_init();
DEBUG_PRINT("nach i2c_init\r\n");
i2c_start(DS1621_ADDRESS + I2C_WRITE);
DEBUG_PRINT("nach i2c_start\r\n");
i2c_write(0xEE);
DEBUG_PRINT("nach i2c_write\r\n");
i2c_stop();
DEBUG_PRINT("nach i2c_stop\r\n");
i2c_start(DS1621_ADDRESS + I2C_WRITE);
DEBUG_PRINT("nach i2c_start\r\n");
i2c_write(0xAA);
DEBUG_PRINT("nach i2c_write\r\n");
i2c_stop();
DEBUG_PRINT("nach i2c_stop\r\n\r\n");
_delay_ms(200);
}

int16_t DS1621_temperatur(void)
{
int16_t temperatur = 0;

DEBUG_PRINT("DS1621_temperatur:\r\n");
DEBUG_PRINT("vor i2c_start\r\n");
i2c_start(DS1621_ADDRESS + I2C_READ);
DEBUG_PRINT("nach i2c_start\r\n");
temperatur = i2c_readAck();
DEBUG_PRINT("nach i2c_readAck\r\n");
i2c_readNak();
DEBUG_PRINT("nach i2c_readNAK\r\n");
i2c_stop();
DEBUG_PRINT("nach i2c_stop\r\n\r\n");
return temperatur;
}

int main( void )
{
UART_init();

// FORMFEED + Intro
UART_puts("\014(Hardware)-TWI Atmega8<->DS1621\r\n\r\n");

DS1621_init();

while (1)
{
char s[5];
int16_t temperatur;
uint8_t i;

// DS1621 auslesen
temperatur = DS1621_temperatur();

// Für UART aufbereiten
if (temperatur < 0)
{
temperatur *= -1;
s[0] = '-';
// todo
}
else
s[0] = '+';

temperatur %= 1000;
s[1] = temperatur/100 + '0';
temperatur %= 100;
s[2] = temperatur/10 + '0';
temperatur %= 10;
s[3] = temperatur + '0';
s[4] = 0;

UART_puts(s);
UART_puts(" \370C\r\n"); // Gradzeichen C

// Nächste Messung in 10s
for (i=0; i<10; i++)
_delay_ms(1000);
}
}

// EOF PFA_TWI_DS1621.c
</syntaxhighlight>

Die C-Quelltexte, das DS1621 Datenblatt und eine fertige Intel-HEX-Datei befinden sich im Archiv [[Media:PFA_TWI_DS1621.zip|PFA_TWI_DS1621.zip]].

Zu Beginn von main() wird die UART mit 9600-8N1 initialisiert. Anschliessend wird der Sensor initialisiert. Als Geräteadresse (0x90) ist dabei im Datenblatt fest vorgegeben und die Adressbits A0, A1, A2 für einen von 8 möglichen DS1621 an einem I2C Bus sind auf LOW eingestellt bzw. mit GND verbunden.

Die eigentliche Messung ist ein einfacher Aufruf der Funktion DS1621_temperatur(). Die Aufbereitung des Ergebnisses ist primitiv gemacht und die Temperatur wird als Text im 10s Abstand an den PC gesendet.

Temperaturen unter 0°C sind nicht getestet. Man sieht auch an DEBUG_PRINT(), dass ich selbst am experimentieren bin. Wer die Debugtexte lesen möchte, kann in PFA_uart.h DEBUG_PRINT() entsprechend definieren.

=== Analog Comparator ===

Die inzwischen gelösten Probleme von "guest" ([http://www.mikrocontroller.net/topic/169773#1623018]) mit dem '''Analog Comparator''' haben mich zum Experimentieren mit dieser Funktion angeregt. Hier im Wiki findet man auch Infos zum Analog Comparator im [[AVR-GCC-Tutorial#AC_.28Analog_Comparator.29|AVR-GCC-Tutorial: AC (Analog_Comparator)]].

Man braucht für die folgenden drei Beispiele z. B. den '''Atmega8''' und eine Drahtbrücke z. B. an dem 40-poligen Stecker J4. Die "Schaltung" arbeitet dann mit der LED2 auf dem Board und mit dem TASTER1 auf dem Board. Die Drahtbrücke verbindet den Taster (Pin PB1 Pinnummer 10 an J4 mit AIN1(PD7) Pinnummer 33 an J4). Die Vergleichsspannung für AIN0 wird auf die interne Bandgap-Referenz gesetzt, so dass kein externer Spannungsanschluss an ANI0(PD6) benötigt wird. Die LED1 an diesem Anschluss bleibt unbenutzt und stört hier nicht.

Das '''erste Beispiel''' zeigt eine grundsätzliche Funktion des Analog Comparators. Die beiden Eingänge AIN0 (int. Bandgap) und AIN1 (0V oder 5V über TASTER1) werden miteinander verglichen und '''wenn sich der Vergleich ändert''', wird der Interrupt ausgelöst.

Hierbei wird der Interrupt nicht abhängig vom IST-Zustand des Vergleichs ausgelöst, sondern abhängig von der Änderung zu einem vorhergehenden Zustand:
* wenn sich der Vergleich ändert (ACIS1 0 und ACIS0 0, ''toggle'' Wechsel): Beispiel 1
* wenn ein Wechsel von AIN1 > AIN0 nach AIN1 < AIN0 stattfindet (ACIS1 1 und ACIS0 0, ''falling'' fallende Flanke)
* wenn ein Wechsel von AIN1 < AIN0 nach AIN1 > AIN0 stattfindet (ACIS1 1 und ACIS0 0, ''rising'' steigende Flanke): Beispiele 2 und 3

Es besteht auch die Möglichkeit das Vergleichssignal OCR vor der Hardware, die die Änderung oben bewertet, abzugreifen und auszugeben. Damit kann man direkt, d.h. statisch im IST-Zustand ohne Infos über den vorhergehenden Zustand AIN0 mit AIN1 vergleichen. Das ist in den folgenden Beispielen aber nicht eingebaut.

<syntaxhighlight lang="c">
/*
Atmega8 @ 12 MHz

Analog Comparator Beispiel #1

Funktion
========
Taster1 triggert den Interrupt ANA_COMP_vect
und in der ISR wird die LED getoggelt

Hardware (Pollin Funk AVR Board):
================================
Interne Bandgap als AIN0 (s.u.)

Taster1 über Brücke an AIN1 (PD7) legen
=> Brücke PB1 (#10 an J4) <----> PD7 (#33 an J4)

Active high LED an PD5
*/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

ISR(ANA_COMP_vect)
{
PORTD ^= (1<<PD5); // LED toogle
}

int main()
{
DDRD = 1<<PD5; // LED Ausgang

/*
Atmega8 Datenblatt S. 193
PD7 = AIN1 = Analog comperator negative input
PD6 = AIN0 = Analog comperator positive input

Register ACSR
=============
ACD: Analog comparator disable
ACBG: Analog Bandgap an AIN0
ACIE: Analog comparator interrupt enable
ACIC: Analog comparator input capture enable
ACIS1/ACIS0: Analog comparator interrupt mode select
00 toggle
01 reserved
10 falling
11 rising
*/
ACSR |= (1<<ACBG);
ACSR |= (1<<ACIE);
sei();

while(1)
{
}
}
</syntaxhighlight>

Beim '''zweiten Beispiel''' löst ein Drücken des Tasters einen Interrupt aus (Trigger). Dadurch wird die LED2 in der ISR eingeschaltet. Nach einer Wartezeit von 1s wird die LED2 dann im Hauptprogramm ausgeschaltet. Ein weiterer Tastendruck innerhalb der Wartezeit verlängert die Wartezeit nicht, d.h. es wird nicht nachgetriggert. Weil _delay_ms() benutzt wird, muss der Quelltext mit Optimierung übersetzt werden (z. B. -Os Option).

<syntaxhighlight lang="c">
/*
Atmega8 @ 12 MHz

Analog Comparator Beispiel #2

Funktion
========
Taster1 triggert den Interrupt ANA_COMP_vect
und in der ISR wird die LED angeschaltet.
In main() wird die LED 1s nach dem auslösenden
Tastendruck ausgeschaltet.Ein neuer Interrupt
innerhalb des 1s Wartens kann das Ausschlaten
nicht verzögern (Nicht nachtriggerbar)

Hardware (Pollin Funk AVR Board):
================================
Interne Bandgap als AIN0 (s.u.)

Taster1 über Brücke an AIN1 (PD7) legen
=> Brücke PB1 (#10 an J4) <----> PD7 (#33 an J4)

Active high LED an PD5
*/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

volatile uint8_t led_ist_an;

ISR(ANA_COMP_vect)
{
PORTD |= (1<<PD5); // LED an
led_ist_an = 1;
}

int main()
{
DDRD = 1<<PD5; // LED Ausgang

/*
Atmega8 Datenblatt S. 193
PD7 = AIN1 = Analog comperator negative input
PD6 = AIN0 = Analog comperator positive input

Register ACSR
=============
ACD: Analog comparator disable
ACBG: Analog Bandgap an AIN0
ACIE: Analog comparator interrupt enable
ACIC: Analog comparator input capture enable
ACIS1/ACIS0: Analog comparator interrupt mode select
00 toggle
01 reserved
10 falling
11 rising
*/
ACSR |= (1<<ACBG);
ACSR |= (1<<ACIS1) | (1<<ACIS0);
ACSR |= (1<<ACIE);
sei();

while(1)
{
if ( led_ist_an )
{
_delay_ms(1000);
PORTD &= ~(1<<PD5); // LED aus
led_ist_an = 0;
}
}
}
</syntaxhighlight>

Beim '''dritten Beispiel''' löst ein Drücken des Tasters einen Interrupt aus (Trigger). Dadurch wird die LED2 in der ISR eingeschaltet. Nach einer Wartezeit von 1s wird die LED2 dann im Hauptprogramm ausgeschaltet. Im Gegensatz zu Beispiel Zwei verlängert weiterer Tastendruck innerhalb der Wartezeit Wartezeit nicht, d.h. es wird nachgetriggert. Weil _delay_ms() benutzt wird, muss der Quelltext mit Optimierung übersetzt werden (z. B. -Os Option).

<syntaxhighlight lang="c">
/*
Atmega8 @ 12 MHz

Analog Comparator Beispiel #3

Funktion
========
Taster1 triggert den Interrupt ANA_COMP_vect
und in der ISR wird die LED angeschaltet.
In main() wird die LED 1s nach dem LETZTEN
Tastendruck ausgeschaltet. Eine neu auftretender
Interrupt kann also das Ausschalten verzögern
(Nachtriggern).

Hardware (Pollin Funk AVR Board):
================================
Interne Bandgap als AIN0 (s.u.)

Taster1 über Brücke an AIN1 (PD7) legen
=> Brücke PB1 (#10 an J4) <----> PD7 (#33 an J4)

Active high LED an PD5
*/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

volatile uint8_t trigger;

ISR(ANA_COMP_vect)
{
PORTD |= (1<<PD5); // LED an
trigger = 1;
}

int main()
{
DDRD = 1<<PD5; // LED Ausgang

/*
Atmega8 Datenblatt S. 193
PD7 = AIN1 = Analog comperator negative input
PD6 = AIN0 = Analog comperator positive input

Register ACSR
=============
ACD: Analog comparator disable
ACBG: Analog Bandgap an AIN0
ACIE: Analog comparator interrupt enable
ACIC: Analog comparator input capture enable
ACIS1/ACIS0: Analog comparator interrupt mode select
00 toggle
01 reserved
10 falling
11 rising
*/
ACSR |= (1<<ACBG);
ACSR |= (1<<ACIS1) | (1<<ACIS0);
ACSR |= (1<<ACIE);
sei();

while(1)
{
if ( trigger )
{
do
{
trigger = 0;
_delay_ms(1000);
} while ( trigger );
PORTD &= ~(1<<PD5); // LED aus
}
}
}
</syntaxhighlight>

Das Warten mit _delay_ms() in den Beispielen würde man in einer "echten" Anwendung anders lösen. Statt in einer Warteschleife Däumchen zu drehen, muss der Atmega8 ja normalerweise weitere Funktionen abarbeiten. Man könnte z. B. einen Timer benutzen und regelmäßig eine Abfrage mithilfe einer selbstgeschriebenen Timeoutfunktion machen, ob die Wartezeit bereits verstrichen ist.

=== Pennen bis der Hund bellt ===

In [http://www.mikrocontroller.net/topic/199684#1959921] fragt Alex, wie man mit dem '''Watchdog''' einen AVR aus dem '''Sleep Mode''' wecken kann. Diese nützliche Anwendung des Watchdogs ist zwar im Artikel [[AVR-Tutorial:_Watchdog#Aufwecken_aus_einem_Sleep_Mode|AVR-Tutorial: Watchdog]] genannt, war aber bisher noch ohne Beispielprogramm. Das soll hier ergänzt werden.

<syntaxhighlight lang="c">
/*
Atmega8 @ 12 MHz --- ODER --- Attiny2313 @ 8 MHz
Pollin-Funk-AVR-Board
*/

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/wdt.h>
#include <avr/sleep.h>
#include <util/delay.h>

#define MS_AKTIV 100

// Aktivierten Watchdog nach Reset erstmal schnell abschalten
// http://www.nongnu.org/avr-libc/user-manual/group__avr__watchdog.html
void get_mcusr(void) \
__attribute__((naked)) \
__attribute__((section(".init3")));

#if defined(__AVR_ATmega8__)
#define MCUSR MCUCSR
#endif

uint8_t mcusr_mirror __attribute__ ((section (".noinit")));
void get_mcusr(void)
{
mcusr_mirror = MCUSR;
MCUSR = 0;
wdt_disable();
}

// LED5 auf Pollin-Funk-AVR-Board als Arbeitsanzeige
inline void LED5_an(void)
{
DDRD |= (1<<PD5); // Ausgang
PORTD |= (1<<PD5); // active high LED an
}

inline void LED5_aus(void)
{
PORTD &= ~(1<<PD5); // active high LED aus
DDRD &= ~(1<<PD5); // Eingang
}

// LED6 auf Pollin-Funk-AVR-Board als Sleepanzeige
inline void LED6_an(void)
{
DDRD |= (1<<PD6); // Ausgang
PORTD |= (1<<PD6); // active high LED an
}

inline void LED6_aus(void)
{
PORTD &= ~(1<<PD6); // active high LED aus
DDRD &= ~(1<<PD6); // Eingang
}

#if defined(__AVR_ATtiny2313__)
ISR(WDT_OVERFLOW_vect)
{
}
#endif

int main(void)
{
uint16_t ms = 0;

LED6_aus();
wdt_enable(WDTO_2S);

while(1)
{
// Beispielhafte Arbeitsroutine
// Mit Watchdogüberwachung gegen schlechtes Benehmen
wdt_reset();
LED5_an();
_delay_ms(1);
ms++;

// Prüfen, ob die Arbeitsroutine MS_AKTIV ms gelaufen ist
// wenn ja, dann SLEEP bis Watchdog nach der Zeit WDTO_2S weckt...
if (ms == MS_AKTIV)
{
LED5_aus();
LED6_an();
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
wdt_reset();
#if defined(__AVR_ATtiny2313__)
cli();
WDTCSR |= (1<<WDIE); // WDT Interrupt enable
#endif
sleep_enable();
#if defined(__AVR_ATtiny2313__)
sei();
#endif
sleep_cpu();
sleep_disable();
ms = 0;
}
}
}
</syntaxhighlight>

Die Arbeitsweise beim '''Atmega8''':

Die LED5 blitzt durch LED5_an() und die Schleife über den Zähler ''ms'' für ''MS_AKTIV'' Millisekunden auf. Ist in der if-Abfrage ''ms'' gleich ''MS_AKTIV'', geht der Atmega8 geht nach dem Abschalten der LED5 und Anschalten der LED6 an der Stelle sleep_cpu() in den Schlafmodus. Nach der Zeit WDTO_2S wird der zu Programmstart mit WDTO_2S aufgesetzte Watchdog aktiv und weckt den AVR aus dem Schlafmodus. Bei dem Atmega8 wird durch den Watchdog immer ein '''System Reset''' ausgelöst, Dies erkennt man daran, dass LED6 zu Beginn von main ausgeschaltet wird, d.h. flackert. Ohne Reset würde LED6 dauernd angeschaltet bleiben.

Die Arbeitsweise beim '''Attiny2313''':

Der Watchdog des Attiny2313 kann nicht nur einen System Reset durchführen, so wie beim Atmega8 oben, sondern es ist auch möglich einen Interrupt mit entsprechender ISR auszuführen. Dazu muss man im WDTCSR Register einstellen, ob nur der Interrupt ausgeführt wird oder ob zuerst der Interrupt ausgeführt wird (beispielsweise zur Datenrettung ins EEPROM oder zur Anzeige einer Statusmeldung) und dann beim nächsten auftretenden Watchdog der System Reset.

Im Beispielprogramm wurde unmittelbar vor dem Sleep der Interrupt Modus plus System Reset Modus eingestellt. Die ISR kann dabei leer sein - es ist nichts zu tun - aber die ISR muss natürlich vorhanden sein. Beim Aufwachen aus dem Sleep löscht der AVR automatisch das WDIE Bit und der nächste Watchdog wird zu einem System Reset führen, d.h. man hat die normale Watchdogfunktion zur Überwachung seines Programms.

Den Unterschied zwischen Atmega8 und Attiny2313 Programm sieht man an dem Verhalten der LED6. Beim Attiny2313 bleibt die LED6 dauerhaft an, d.h.der Programmteil zwischen main und while wird nur einmal beim Power-Up bzw. sonstigen Resets außer den Watchdog-Resets durchlaufen.

== Forenbeiträge ==

* [http://www.mikrocontroller.net/topic/82156 Optokoppler auf Pollin Funk Evaluations-Board]
* [http://www.mikrocontroller.net/topic/102101 Pollin evaluation nur Fuses geht nicht aber programmieren!]
* [http://www.mikrocontroller.net/topic/119579 Pollin Mainboard/Funkboard und RFM12 Funkmodul]
* Kritik an den "Entprellkondensatoren" der Taster: [http://www.mikrocontroller.net/topic/122450#1113811], [http://www.mikrocontroller.net/topic/122551#1118124], [http://www.mikrocontroller.net/topic/152361#1431824] und [http://www.mikrocontroller.net/topic/159743#1518616]
* [http://www.mikrocontroller.net/topic/147072#1369628 Pollin Funkboard mit Mega8, [[RFM12]], [[LCD]], [[DCF77]] und [[DS18S20]]]

== Scratchpad ==
(Vorgemerktes für neue Abschnitte, Ergänzungen und Korrekturen)

* Differentielle ADC-Messung [http://www.mikrocontroller.net/topic/165949]

* Mittelwertbildung und gleitender Durchschnitt [http://www.mikrocontroller.net/topic/166587], [http://www.mikrocontroller.net/topic/170608#1631873]

* LED Dimmen über ADC [http://www.mikrocontroller.net/topic/169364#1619346]

* RC5 Erweiterung [http://www.mikrocontroller.net/topic/168346#1613115]

* DS18S20, DS18B20 [http://www.mikrocontroller.net/topic/14792#1631385], [http://www.mikrocontroller.net/topic/170112#1626088], [http://www.mikrocontroller.net/topic/171691]

* DS1621 [http://www.mikrocontroller.net/topic/174906#1681232], [http://www.mikrocontroller.net/topic/192823#1886493]

* Piezosummer ohne Elektronik [http://www.mikrocontroller.net/topic/118816?page=2#1106912]

* Input Capture [http://www.mikrocontroller.net/topic/204072#2011304]

== Weblinks ==

* [http://www.pollin.de/shop/downloads/D810046B.PDF Datenblatt Funk-AVR-Evaluationsboard (PDF)] Best.nr. 810046 von www.pollin.de 
* [http://www.atmel.com/dyn/resources/prod_documents/doc2486.pdf Datenblatt Atmega8 (PDF)]
* [http://www.controller-designs.de/index.php?lang=de&cat=internal&cont=info_pollinfunkboard&sub= Erfahrungsbericht] von Marco Schmoll (www.controller-designs.de). Bezieht sich auf die ältere v1.0 bzw. v1.1 Hardware.
* [http://www.dh2faa.de/mctrl2.html Ansteuerung mit BASCOM] von Heiko Bujak. Siehe auch Beitrag im Forum [http://www.mikrocontroller.net/topic/119579]
* [[Pollin ATMEL Evaluations-Board]]

[[Category:AVR-Boards]]
[[Kategorie:RFM12]]

Entprellung

2014-02-17T12:32:06Z

145.225.60.4: /* Flankenerkennung */

== Problembeschreibung ==
Mechanische [[Schalter]] wie [[Drehgeber]] neigen beim Ein- und Ausschalten zum sogenannten '''Prellen''', d.h sie schalten schnell mehrfach aus und ein, verursacht durch mechanische Vibrationen des Schaltkontaktes, sofern sie nicht dagegen geschützt sind. Vereinfacht dargestellt, sieht eine von einem Schalter oder Taster geschaltete Spannung beim Schalten wie folgt aus:

[[Bild:Entprellen.png]]

Für die Vermeidung bzw. Auswertung dieses unsauberen Signals gibt es verschiedene Ansätze:

== Hardwareentprellung ==

===Prellfreie Schalter===

Für Spezialanwendungen hält die elektromechanische Industrie verschiedene Sonderkonstruktionen bereit, die saubere Schaltzustände nach Aussen generieren, indem sie entweder eine mechanische Dämpfung in Form eines selbsthemmenden Federmechanismus oder eine integrierte elektronische Signalverzögerung benutzen.

Solche Systeme sind jedoch teuer und werden meist nur im Leistungsbereich eingesetzt.

===Wechselschalter===

Für die Entprellung von Wechselschaltern (engl. Double Throw Switch) kann ein klassisches RS-[[Flipflop]] genutzt werden. Bei dieser Variante werden neben zwei NAND-Gattern nur noch zwei Pull-Up Widerstände benötigt.

[[Bild:NAND_debouncer.png|thumb|left|350px|'''Taster entprellen mit NAND-RS-Flipflop''']]

 

In der gezeigten Schalterstellung liegt an der Position /S der Pegel 0 an. Damit ist das Flipflop gesetzt und der Ausgang auf dem Pegel 1. Schließt der Schalter zwischen den Kontakten 2 und 3, liegt an der Postion /R der Pegel 0 an. Dies bedeutet, dass der Ausgang des Flipflops auf den Pegel 0 geht. Sobald der Schalter von einem zum anderen Kontakt wechselt, beginnt er in der Regel zu prellen. Während des Prellens wechselt der Schalter zwischen den beiden Zuständen "Schalter berührt Kontakt" und "Schalter ist frei in der Luft". Der Ausgang des Flipflops bleibt in dieser Prellzeit aber stabil, da der Schalter während des Prellens nie den gegenüberliegenden Kontakt berührt und das RS-Flipflop seinen Zustand allein halten kann. Die Prellzeit ist stark vom Schaltertyp abhängig und liegt zwischen 0,1 und 10ms. Die Dimensionierung der Widerstände ist relativ unkritisch. Als Richtwert können hier 100kOhm verwendet werden.

====Wechselschalter ohne Flip-Flop====

Wenn man mal gerade kein Flip-Flop zur Hand hat, kann man sich auch mit dieser Schaltung behelfen.

[[Bild:WechselEntprellC.PNG|thumb|left|350px|'''Wechsler entprellen mit Kondensator''']]

 

Zur Funktionsweise:
Beim Umschalten wird der Kondensator immer sofort umgeladen.
Während der Kontakt prellt, befindet er sich in der Luft und hat keinerlei Verbindung. Während dieser Zeit übernimmt der Kondensator das halten des Pegels.

Dimensionierung:
Ist der entprellte Taster an ein IC Angeschlossen, ist der ''Input Leakage Current'' der ausschlaggebende Strom. Falls weitere Ströme fließen sind diese mit zu berücksichtigen. Bei einem Mikrocontroller von Atmel sind 1µA typisch.
Es gilt:
:<math>\frac{dU}{dt} = \frac{I}{C}</math>
Da eine Prellung ca. 10ms dauert und die Spannung in dieser Zeit beispielsweise um maximal 0,5V fallen soll kommt man auf folgende Kapazität:
:<math> C = \frac{I \cdot dt}{dU} = \frac{1\mu A \cdot 10ms}{0,5V} = 20nF </math>

Um Stromspitzen zu verringern kann ein Widerstand mit eingefügt werden. Eine Zeitkonstante von 1µs bis 1ms scheint sinnvoll. Also 500 Ohm bis 500kOhm sind nutzbar, wobei bei niedrigem Widerstand die Stromspitzen höher sind, und bei 500kOhm der Pinstrom störend wird.

===Einfacher Taster===

Auch wenn das RS-Flipflop sehr effektiv ist, wird diese Variante der Entprellung nur selten angewendet. Grund dafür ist, dass in Schaltungen häufiger einfache Taster eingesetzt werden. Diese sind oft kleiner und preisgünstiger. Um einfache Taster (engl. Single Throw Switch) zu entprellen, kann ein einfacher RC-Tiefpass eingesetzt werden. Hierbei wird ein Kondensator über einen Widerstand je nach Schalterstellung auf- oder entladen. Das RC-Glied bildet einen Tiefpass, sodass die Spannung über den Kondensator nicht von einen Pegel auf den anderen springen kann.

[[Bild:RC_debouncer.png|thumb|left|300px|Taster entprellen mit RC-Entpreller]]

[[Datei:Entprellen1a.png|thumb|350px| Entstehender Spannungsverlauf]]
{{Absatz}}

Wenn der Schalter geöffnet ist, lädt sich der Kondensator langsam über die beiden Widerstände R1 und R2 auf Vcc auf. Beim Erreichen der Umschaltschwelle springt der Ausgang auf den Pegel 0. Wird der Schalter geschlossen, entlädt sich der Kondensator langsam über den Widerstand R2. Demnach ändert sich der Ausgang des Inverters auf den Pegel 1. Während der Taster prellt, kann sich die Spannung über dem Kondensator nicht sprunghaft ändern, da das Auf- und Entladen eher langsam über die Widerstände erfolgt. Außerdem sind die Schaltschwellen für den Übergang LOW->HIGH und HIGH->LOW stark verschieden (Hysterese, siehe Artikel [[Schmitt-Trigger]]). Bei richtiger Dimensionierung der Bauelemente wird somit der Ausgang des Inverters prellfrei.

Zu beachten ist, dass der Inverter '''unbedingt''' einer mit [[Schmitt-Trigger]] Eingängen sein muss, weil bei Standard-Logikeingängen im Bereich von üblicherweise 0,8V - 2,0V der Ausgang nicht definiert ist. Als Inverter kann zum Beispiel der 74HC14 oder der CD40106 (pinkompatibel) eingesetzt werden. Alternativ kann auch ein CD4093 eingesetzt werden. Bei dem CD4093 handelt es sich um NAND-Gatter mit Schmitt-Trigger-Eingängen. Um aus einem NAND-Gatter einen Inverter zu machen, müssen einfach nur die beiden Eingänge verbunden werden oder ein Eingang fest auf HIGH gelegt werden.

Für eine geeignete Dimensionierung muss man etwas mit den Standardformeln für einen Kondensator jonglieren. Die Spannung über den Kondensator beim Entladen berechnet sich nach:
:<math>U_C(t) = U_0 \cdot e^{\frac{-t}{R_2 C_1}}</math>

Damit der Ausgang des Inverters stabil ist, muss die Spannung über den Kondensator und damit die Spannung am Eingang des Inverters über der Spannung bleiben, bei welcher der Inverter umschaltet. Diese Schwellwertspannung ist genau die zeitabhängige Spannung über den Kondensator.
:<math>U_C(t)\!\ = U_{th}</math>

Durch Umstellen der Formel ergibt sich nun:
:<math>R_2=\frac{-t}{C_1 \cdot ln\left(\frac{U_{th}}{U_0} \right)}</math>

Ein Taster prellt üblicherweise etwa 10ms. Zur Sicherheit kann bei der Berechnung des Widerstandes eine Prellzeit von 20ms angenommen werden. U_0 ist die Betriebsspannung also Vcc. Die Schwellwertspannung muss aus dem Datenblatt des eingesetzten Schmitt-Triggers abgelesen werden. Beim 74HC14 beträgt der gesuchte Wert 2,0V. Nimmt man für den Kondensator 1µF und beträgt die Betriebsspannung 5V, ergibt sich für den Widerstand ein Wert von etwa 22kOhm.

Wird der Schalter geöffnet, lädt sich der Kondensator nach folgender Formel auf:
:<math>U_C(t) = U_0 \cdot \left( 1-e^{\frac{-t}{(R_1+R_2)\cdot C_1}} \right)</math>

Mit U_th=U_C ergibt das Umstellen nach (R_1+R_2):
:<math>R_1+R_2 = \frac{-t}{C_1 \cdot ln\left(1-\frac{U_{th}}{U_0} \right)} </math>

Für die Schwellspannung lässt sich aus dem Datenblatt ein Wert von 2,3V ablesen. Mit diesem Wert und den Annahmen von oben ergibt sich für R_1+R_2 ein Wert von 32kOhm. Somit ergibt sich für R_1 ein Wert von etwa 10kOhm.

Anmerkung: Beim 74LS14 von Hitachi z. B. sind die oberen und unteren Schaltschwellwerte unterschiedlich. Es muss darauf geachtet werden, dass U_{th} beim Entladen die untere Schwelle und U_{th} beim Laden die obere Schwelle einnimmt.

== Softwareentprellung ==

In den Zeiten der elektronischen Auswertung von Tastern und Schaltern ist das softwaretechnische Entprellen oft billiger, als die Benutzung eines teuren Schalters. Daher werden heute z.B. auch Computertastaturen nicht mehr mit prellarmen Tasten oder Entprellkondensatoren ausgestattet.

Bei Verwendung des in den meisten Geräten ohnehin vorhandenen Mikrocontrollers z.B., kann man sich die zusätzliche Hardware sparen, da die Entprellung in Software praktisch genauso gut funktioniert. Dabei ist nur zu beachten, dass zusätzliche Rechenleistung und je nach Umsetzung auch einige Hardwareressourcen (z.B. Timer) benötigt werden.

=== Flankenerkennung ===
Bei einem Taster gibt es insgesamt 4 theoretische Zustände:

* 1. war nicht gedrückt und ist nicht gedrückt
* 2. war nicht gedrückt und ist gedrückt (steigende Flanke)
* 3. war gedrückt und ist immer noch gedrückt
* 4. war gedrückt und ist nicht mehr gedrückt (fallende Flanke)

Diese einzelnen Zustände lassen sich jetzt bequem abfragen/durchlaufen. Die Entprellung geschieht dabei durch die ganze Laufzeit des Programms. Die Taster werden hierbei als Active-Low angeschlossen, um die internen Pull-Ups zu nutzen.

Diese Routine gibt für den Zustand "steigende Flanke" den Wert "1" zurück, sonst "0"

<syntaxhighlight lang="c">
#define TASTERPORT PINC
#define TASTERBIT PINC1

char taster(void)
{
static unsigned char zustand;
char rw = 0;

if(zustand == 0 && !(TASTERPORT & (1<<TASTERBIT))) //Taster wird gedrueckt (steigende Flanke)
{
zustand = 1;
rw = 1;
}
else if (zustand == 1 && !(TASTERPORT & (1<<TASTERBIT))) //Taster wird gehalten
{
zustand = 2;
rw = 0;
}
else if (zustand == 2 && (TASTERPORT & (1<<TASTERBIT))) //Taster wird losgelassen (fallende Flanke)
{
zustand = 3;
rw = 0;
}
else if (zustand == 3 && (TASTERPORT & (1<<TASTERBIT))) //Taster losgelassen
{
zustand = 0;
rw = 0;
}

return rw;
}
</syntaxhighlight>

Eine Erweiterung, damit beliebig lange das Halten einer Taste erkannt wird kann man ganz einfach so implementieren:

<syntaxhighlight lang="c">
// zustand kann entweder zum ersten mal als gehalten detektiert werden oder aber jedes weitere mal
else if (((zustand == 1) || (zustand == 2)) && !(TASTERPORT & (1<<TASTERBIT))) //Taster wird gehalten
{
zustand = 2;
rw = 0;
}
</syntaxhighlight>

=== Warteschleifen-Verfahren ===

Soll nun mit einem Mikrocontroller gezählt werden, wie oft ein Kontakt oder ein Relais geschaltet wird, muss das Prellen des Kontaktes exakt berücksichtigt - und von einem gewollten Mehrfachschalten abgegrenzt werden, da sonst möglicherweise Fehlimpulse gezählt- oder andererseits echte Schaltvorgänge übersprungen werden. Dies muss beim Schreiben des Programms hinsichtlich des Abtastens des Kontaktes unbedingt Rechnung getragen werden.

Beim folgenden einfachen Beispiel für eine Entprellung ist zu beachten, dass der AVR im Falle eines Tastendrucks 200ms wartet, also brach liegt. Bei zeitkritischen Anwendungen sollte man ein anderes Verfahren nutzen (z. B. Abfrage der Tastenzustände in einer Timer-Interrupt-Service-Routine).

<syntaxhighlight lang="c">
#include <avr/io.h>
#include <inttypes.h>
#ifndef F_CPU
#warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
#define F_CPU 3686400UL /* Quarz mit 3.6864 Mhz */
#endif
#include <util/delay.h> /* bei alter avr-libc: #include <avr/delay.h> */

/* Einfache Funktion zum Entprellen eines Tasters */
inline uint8_t debounce(volatile uint8_t *port, uint8_t pin)
{
if ( !(*port & (1 << pin)) )
{
/* Pin wurde auf Masse gezogen, 100ms warten */
_delay_ms(50); // Maximalwert des Parameters an _delay_ms
_delay_ms(50); // beachten, vgl. Dokumentation der avr-libc
if ( *port & (1 << pin) )
{
/* Anwender Zeit zum Loslassen des Tasters geben */
_delay_ms(50);
_delay_ms(50);
return 1;
}
}
return 0;
}

int main(void)
{
DDRB &= ~( 1 << PB0 ); /* PIN PB0 auf Eingang Taster) */
PORTB |= ( 1 << PB0 ); /* Pullup-Widerstand aktivieren */
...
if (debounce(&PINB, PB0))
{
/* Falls Taster an PIN PB0 gedrueckt */
/* LED an Port PD7 an- bzw. ausschalten: */
PORTD = PORTD ^ ( 1 << PD7 );
}
...
}
</syntaxhighlight>

Die obige Routine hat leider mehrere Nachteile:
* sie detektiert nur das Loslassen (unergonomisch)
* sie verzögert die Mainloop immer um 100ms bei gedrückter Taste
* sie verliert Tastendrücke, je mehr die Mainloop zu tun hat.

Eine ähnlich einfach zu benutzende Routine, aber ohne all diese Nachteile findet sich im Forenthread
[http://www.mikrocontroller.net/topic/164194#new Entprellung für Anfänger]

Der ''DEBOUNCE'' Befehl in dem BASIC-Dialekt BASCOM für AVR ist ebenfalls nach dem Warteschleifen-Verfahren programmiert. Die Wartezeit beträgt standardmäßig 25 ms, kann aber vom Anwender überschrieben werden. Vgl. [http://avrhelp.mcselec.com/bascom-avr.html?DEBOUNCE BASCOM Online-Manual zu DEBOUNCE].

Eine C-Implementierung für eine Tastenabfrage mit Warteschleife ist im Artikel [[AVR-GCC-Tutorial#IO-Register_als_Parameter_und_Variablen|AVR-GCC-Tutorial: IO-Register als Parameter und Variablen]] angeben.

Der Nachteil dieses Verfahrens ist, dass der Controller durch die Warteschleife blockiert wird. Günstiger ist die Implementierung mit einem Timer-Interrupt.

==== Warteschleifenvariante mit Maske und Pointer (nach Christian Riggenbach) ====

Hier eine weitere Funktion, um Taster zu entprellen: Durch den zusätzlichen Code kann eine Entprellzeit von durchschnittlich 1-3ms (mindestens 8*150µs = 1ms) erreicht werden. Grundsätzlich prüft die Funktion den Pegel der Pins auf einem bestimmten Port. Wenn die/der Pegel 8 Mal konstant war, wird die Schleife verlassen. Diese Funktion kann sehr gut eingesetzt werden, um in einer Endlosschleife Taster anzufragen, da sie, wie erwähnt, eine kurze Wartezeit hat.

<syntaxhighlight lang="c">
void entprellung( volatile uint8_t *port, uint8_t maske ) {
uint8_t port_puffer;
uint8_t entprellungs_puffer;

for( entprellungs_puffer=0 ; entprellungs_puffer!=0xff ; ) {
entprellungs_puffer<<=1;
port_puffer = *port;
_delay_us(150);
if( (*port & maske) == (port_puffer & maske) )
entprellungs_puffer |= 0x01;
}
}
</syntaxhighlight>
Die Funktion wird wie folgt aufgerufen:
<syntaxhighlight lang="c">
// Bugfix 20100414
// http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_port_pass
entprellung( &PINB, (1<<PINB2) ); // ggf. Prellen abwarten
if( PINB & (1<<PINB2) ) // dann stabilen Wert einlesen
{
// mach was
}
else
{
// mach was anderes
}
</syntaxhighlight>
Als Maske kann ein beliebiger Wert übergeben werden. Sie verhindert, dass nichtverwendete Taster die Entprellzeit negativ beeinflussen.

==== Debounce-Makro von Peter Dannegger ====

Peter Dannegger hat in [http://www.mikrocontroller.net/topic/164194#1566921 "Entprellen für Anfänger"] folgende vereinfachtes Entprellverfahren beschrieben. Das Makro arbeitet in der Originalversion mit ''active low'' geschalteten Tastern, kann aber einfach für ''active high'' geschaltete Taster angepasst werden ([[Pollin Funk-AVR-Evaluationsboard#Tasty Reloaded|Tasty Reloaded]]).

<syntaxhighlight lang="c">
/************************************************************************/
/* */
/* Not so powerful Debouncing Example */
/* No Interrupt needed */
/* */
/* Author: Peter Dannegger */
/* */
/************************************************************************/
// Target: ATtiny13

#include <avr/io.h>
#define F_CPU 9.6e6
#include <util/delay.h>

#define debounce( port, pin ) \
({ \
static uint8_t flag = 0; /* new variable on every macro usage */ \
uint8_t i = 0; \
\
if( flag ){ /* check for key release: */ \
for(;;){ /* loop ... */ \
if( !(port & 1<<pin) ){ /* ... until key pressed or ... */ \
i = 0; /* 0 = bounce */ \
break; \
} \
_delay_us( 98 ); /* * 256 = 25ms */ \
if( --i == 0 ){ /* ... until key >25ms released */ \
flag = 0; /* clear press flag */ \
i = 0; /* 0 = key release debounced */ \
break; \
} \
} \
}else{ /* else check for key press: */ \
for(;;){ /* loop ... */ \
if( (port & 1<<pin) ){ /* ... until key released or ... */ \
i = 0; /* 0 = bounce */ \
break; \
} \
_delay_us( 98 ); /* * 256 = 25ms */ \
if( --i == 0 ){ /* ... until key >25ms pressed */ \
flag = 1; /* set press flag */ \
i = 1; /* 1 = key press debounced */ \
break; \
} \
} \
} \
i; /* return value of Macro */ \
})

/*
Testapplication
*/
int main(void)
{
DDRB &= ~(1<<PB0);
PORTB |= 1<<PB0;
DDRB |= 1<<PB2;
DDRB &= ~(1<<PB1);
PORTB |= 1<<PB1;
DDRB |= 1<<PB3;
for(;;){
if( debounce( PINB, PB1 ) )
PORTB ^= 1<<PB2;
if( debounce( PINB, PB0 ) )
PORTB ^= 1<<PB3;
}
}

</syntaxhighlight>

Wenn das Makro für die gleiche Taste (Pin) an mehreren Stellen aufgerufen werden soll, muss eine Funktion angelegt werden, damit beide Aufrufe an die gleiche Zustandsvariable ''flag'' auswerten [http://www.mikrocontroller.net/topic/195914#1918727]:

<syntaxhighlight lang="c">
// Hilfsfunktion
uint8_t debounce_C1( void )
{
return debounce(PINC, PC1);
}

// Beispielanwendung
int main(void)
{
DDRB |= 1<<PB2;
DDRB |= 1<<PB3;
DDRC &= ~(1<<PC1);
PORTC |= 1<<PC1; // Pullup für Taster

for(;;){
if( debounce_C1() ) // nicht: debounce(PINC, PC1)
PORTB ^= 1<<PB2;
if( debounce_C1() ) // nicht: debounce(PINC, PC1)
PORTB ^= 1<<PB3;
}
}
</syntaxhighlight>

=== Timer-Verfahren (nach Peter Dannegger) ===

==== Grundroutine (AVR Assembler) ====

Siehe dazu: [http://www.mikrocontroller.net/forum/read-4-20435.html#new Forum]

Vorteile
* besonders kurzer Code
* schnell

Außerdem können 8 Tasten (aktiv low) gleichzeitig bearbeitet werden, es dürfen also
alle exakt zur selben Zeit gedrückt werden. Andere Routinen können z. B. nur eine Taste verarbeiten, d.h. die zuerst oder zuletzt gedrückte gewinnt, oder es kommt Unsinn heraus.

Die eigentliche Einlese- und Entprellroutine ist nur 8 Instruktionen
kurz. Der entprellte Tastenzustand ist im Register ''key_state''. Mit nur 2 weiteren Instruktionen wird dann der Wechsel von ''Taste offen'' zu
''Taste gedrückt'' erkannt und im Register ''key_press'' abgelegt. Im Beispielcode werden dann damit 8 LEDs ein- und ausgeschaltet. Jede Taste entspricht einem Bit in den Registern, d.h. die Verarbeitung erfolgt bitweise mit logischen Operationen. Zum Verständnis empfiehlt es sich daher, die Logikgleichungen mit Gattern für ein Bit = eine Taste aufzumalen. Die Register kann man sich als Flipflops denken, die mit der Entprellzeit als Takt arbeiten. D.h. man kann das auch so z. B. in einem GAL22V10 realisieren.

Als Kommentar sind neben den einzelnen Instruktionen alle 8 möglichen
Kombinationen der 3 Signale dargestellt.

Beispielcode für AVR (Assembler):

<syntaxhighlight lang="avrasm">
.nolist
.include "c:\avr\inc\1200def.inc"
.list
.def save_sreg = r0
.def iwr0 = r1
.def iwr1 = r2

.def key_old = r3
.def key_state = r4
.def key_press = r5

.def leds = r16
.def wr0 = r17

.equ key_port = pind
.equ led_port = portb

rjmp init
.org OVF0addr ;timer interrupt 24ms
in save_sreg, SREG
get8key: ;/old state iwr1 iwr0
mov iwr0, key_old ;00110011 10101010 00110011
in key_old, key_port ;11110000
eor iwr0, key_old ; 11000011
com key_old ;00001111
mov iwr1, key_state ; 10101010
or key_state, iwr0 ; 11101011
and iwr0, key_old ; 00000011
eor key_state, iwr0 ; 11101000
and iwr1, iwr0 ; 00000010
or key_press, iwr1 ;store key press detect
;
; insert other timer functions here
;
out SREG, save_sreg
reti
;-------------------------------------------------------------------------
init:
ldi wr0, 0xFF
out ddrb, wr0
ldi wr0, 1<<CS02 | 1<<CS00 ;divide by 1024 * 256
out TCCR0, wr0
ldi wr0, 1<<TOIE0 ;enable timer interrupt
out TIMSK, wr0

clr key_old
clr key_state
clr key_press
ldi leds, 0xFF
main: cli
eor leds, key_press ;toggle LEDs
clr key_press ;clear, if key press action done
sei
out led_port, leds
rjmp main
;-------------------------------------------------------------
</syntaxhighlight>

==== Komfortroutine (C für AVR) ====

Siehe dazu: [http://www.mikrocontroller.net/forum/read-4-310276.html Forum]

'''Anmerkung''' Wenn statt active-low (Ruhezustand High) active-high (Ruhezustand Low) verwendet wird muss eine Zeile geändert werden siehe:
[http://www.mikrocontroller.net/forum/read-4-310276.html gesamter Beitrag im Forum],
[http://www.mikrocontroller.net/topic/48465#606555 Stelle 1 im Beitrag], ([http://www.mikrocontroller.net/topic/48465#2306398 Stelle 2 im Beitrag] muss *nicht* geändert werden, da hier die Polarität gar keinen Einfluß hat).

Funktionsprinzip wie oben plus zusätzliche Features:
* Kann Tasten sparen durch unterschiedliche Aktionen bei kurzem oder langem Drücken
* Wiederholfunktion, z. B. für die Eingabe von Werten

Das Programm ist für avr-gcc/avr-libc geschrieben, kann aber mit ein paar Anpassungen auch mit anderen Compilern und Mikrocontrollern verwendet werden. Eine Portierung für den AT91SAM7 findet man [http://www.google.com/codesearch?q=show:ac2viP-2E2Y:pzkOO5QRsoc:RPICuprYy-A&sa=N&cd=1&ct=rc&cs_p=svn://mikrocontroller.net/mp3dec/trunk&cs_f=keys.c#a0 hier] (aus dem Projekt [[ARM MP3/AAC Player]]).
<syntaxhighlight lang="c">
/************************************************************************/
/* */
/* Debouncing 8 Keys */
/* Sampling 4 Times */
/* With Repeat Function */
/* */
/* Author: Peter Dannegger */
/* danni@specs.de */
/* */
/************************************************************************/

#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.h>

#ifndef F_CPU
#define F_CPU 1000000 // processor clock frequency
#warning kein F_CPU definiert
#endif

#define KEY_DDR DDRB
#define KEY_PORT PORTB
#define KEY_PIN PINB
#define KEY0 0
#define KEY1 1
#define KEY2 2
#define ALL_KEYS (1<<KEY0 | 1<<KEY1 | 1<<KEY2)

#define REPEAT_MASK (1<<KEY1 | 1<<KEY2) // repeat: key1, key2
#define REPEAT_START 50 // after 500ms
#define REPEAT_NEXT 20 // every 200ms

#define LED_DDR DDRA
#define LED_PORT PORTA
#define LED0 0
#define LED1 1
#define LED2 2

volatile uint8_t key_state; // debounced and inverted key state:
// bit = 1: key pressed
volatile uint8_t key_press; // key press detect

volatile uint8_t key_rpt; // key long press and repeat

ISR( TIMER0_OVF_vect ) // every 10ms
{
static uint8_t ct0, ct1, rpt;
uint8_t i;

TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5); // preload for 10ms

i = key_state ^ ~KEY_PIN; // key changed ?
ct0 = ~( ct0 & i ); // reset or count ct0
ct1 = ct0 ^ (ct1 & i); // reset or count ct1
i &= ct0 & ct1; // count until roll over ?
key_state ^= i; // then toggle debounced state
key_press |= key_state & i; // 0->1: key press detect

if( (key_state & REPEAT_MASK) == 0 ) // check repeat function
rpt = REPEAT_START; // start delay
if( --rpt == 0 ){
rpt = REPEAT_NEXT; // repeat delay
key_rpt |= key_state & REPEAT_MASK;
}
}

///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed. Each pressed key is reported
// only once
//
uint8_t get_key_press( uint8_t key_mask )
{
cli(); // read and clear atomic !
key_mask &= key_press; // read key(s)
key_press ^= key_mask; // clear key(s)
sei();
return key_mask;
}

///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed long enough such that the
// key repeat functionality kicks in. After a small setup delay
// the key is reported being pressed in subsequent calls
// to this function. This simulates the user repeatedly
// pressing and releasing the key.
//
uint8_t get_key_rpt( uint8_t key_mask )
{
cli(); // read and clear atomic !
key_mask &= key_rpt; // read key(s)
key_rpt ^= key_mask; // clear key(s)
sei();
return key_mask;
}

///////////////////////////////////////////////////////////////////
//
// check if a key is pressed right now
//
uint8_t get_key_state( uint8_t key_mask )

{
key_mask &= key_state;
return key_mask;
}

///////////////////////////////////////////////////////////////////
//
uint8_t get_key_short( uint8_t key_mask )
{
cli(); // read key state and key press atomic !
return get_key_press( ~key_state & key_mask );
}

///////////////////////////////////////////////////////////////////
//
uint8_t get_key_long( uint8_t key_mask )
{
return get_key_press( get_key_rpt( key_mask ));
}

int main( void )
{
LED_PORT = 0xFF;
LED_DDR = 0xFF;

// Configure debouncing routines
KEY_DDR &= ~ALL_KEYS; // configure key port for input
KEY_PORT |= ALL_KEYS; // and turn on pull up resistors

TCCR0 = (1<<CS02)|(1<<CS00); // divide by 1024
TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5); // preload for 10ms
TIMSK |= 1<<TOIE0; // enable timer interrupt

sei();

while(1){
if( get_key_short( 1<<KEY1 ))
LED_PORT ^= 1<<LED1;

if( get_key_long( 1<<KEY1 ))
LED_PORT ^= 1<<LED2;

// single press and repeat

if( get_key_press( 1<<KEY2 ) || get_key_rpt( 1<<KEY2 )){
uint8_t i = LED_PORT;

i = (i & 0x07) | ((i << 1) & 0xF0);
if( i < 0xF0 )
i |= 0x08;
LED_PORT = i;
}
}
}
</syntaxhighlight>

Das single-press-und-repeat-Beispiel geht nicht in jeder Beschaltung; folgendes Beispiel sollte universeller sein (einzelne LED an/aus):
<syntaxhighlight lang="c">
// single press and repeat
if( get_key_press( 1<<KEY2 ) || get_key_rpt( 1<<KEY2 ))
LED_PORT ^=0x08;
</syntaxhighlight>

===== Funktionsweise =====
Der Code basiert auf 8 parallelen vertikalen Zählern, die über die Variablen ct0 und ct1 aufgebaut werden

[[Bild:VertCount.png|framed|center|'''8 vertikale Zähler in 2 8-Bit Variablen''']]

wobei jeweils ein Bit in ct0 mit dem gleichwertigen Bit in ct1 zusammengenommen einen 2-Bit-Zähler bildet.
Der Code der sich um die 8 Zähler kümmert, ist so geschrieben, daß er alle 8 Zähler gemeinsam parallel behandelt.

<syntaxhighlight lang="c">
i = key_state ^ ~KEY_PIN; // key changed ?
</syntaxhighlight>
i enthält an dieser Stelle für jede Taste, die sich im Vergleich mit dem vorhergehenden entprellten Zustand (keystate) verändert hat, ein 1 Bit.

<syntaxhighlight lang="c">
ct0 = ~( ct0 & i ); // reset or count ct0
ct1 = ct0 ^ (ct1 & i); // reset or count ct1
</syntaxhighlight>

Diese beiden Anweisungen erniedrigen den 2-Bit Zähler ct0/ct1 für jedes Bit um 1, welches in i gesetzt ist. Liegt an der entsprechenden Stelle in i ein 0 Bit vor (keine Änderung des Zustands), so wird der Zähler ct0/ct1 für dieses Bit auf 1 gesetzt.
Der Grundzustand des Zählers ist als ct0 == 1 und ct1 == 1 (Wert 3). Der Zähler zählt daher mit jedem ISR Aufruf, bei dem die Taste im Vergleich zu keystate als verändert erkannt wurde

ct1 ct0
1 1 // 3
1 0 // 2
0 1 // 1
0 0 // 0
1 1 // 3

<syntaxhighlight lang="c">
i &= ct0 & ct1; // count until roll over ?
</syntaxhighlight>
in i bleibt nur dort ein 1-Bit erhalten, wo sowohl in ct1 als auch in ct0 ein 1 Bit vorgefunden wird, der betreffenede Zähler also bis 3 zählen konnte. Durch die zusätzliche Verundung mit i wird der Fall abgefangen, dass ein konstanter Zählerwert von 3 in i ein 1 Bit hinterlässt. Im Endergebnis bedeutet dass, dass nur ein Zählerwechsel von 0 auf 3 zu einem 1 Bit an der betreffenden Stelle in i führt, aber auch nur dann, wenn in i an dieser Bitposition ebenfalls ein 1 Bit war (welches wiederrum deswegen auf 1 war, weil an diesem Eingabeport eine Veränderung zum letzten bekannten entprellten Zustand festgestellt wurde). alles zusammengenommen heißt das, dass ein Tastendruck dann erkannt wird, wenn die Taste 4 mal hintereinander in einem anderen Zustand vorgefunden wurde als dem zuletzt bekannten entprellten Tastenzustand.

An dieser Stelle ist i daher ein Vektor von 8 Bits, von denen jedes einzelne der Bits darüber Auskunft gibt, ob die entsprechende Taste mehrmals hintereinander im selben Zustand angetroffen wurde, der nicht mit dem zuletzt bekannten Tastenzustand übereinstimmt. Ist das der Fall, dann wird eine entsprechende Veränderung des Tastenzustands in key_state registriert
<syntaxhighlight lang="c">
key_state ^= i; // then toggle debounced state
</syntaxhighlight>
und wenn sich in key_state das entsprechende Bit von 0 auf 1 verändert hat, wird dieses Ereignis als 'Taste wurde niedergedrückt' gewertet.
<syntaxhighlight lang="c">
key_press |= key_state & i; // 0->1: key press detect
</syntaxhighlight>

Damit ist der Tasteneingang entprellt. Und zwar sowohl beim Drücken einer Taste als auch beim Loslassen (damit Tastenpreller beim Loslassen nicht mit dem Niederdrücken einer Taste verwechselt werden). Der weitere Code beschäftigt sich dann nur noch damit, diesen entprellten Tastenzustand weiter zu verarbeiten.

Der Codeteil sieht durch die Verwendung der vielen bitweisen Operationen relativ komplex aus. Behält man aber im Hinterkopf, dass einige der bitweisen wie ein 'paralles If' gleichzeitig auf allen 8 Bits eingesetzt werden, dann vereinfacht sich vieles. Ein
<syntaxhighlight lang="c">
key_press |= key_state & i;
</syntaxhighlight>
ist nichts anderes als ein
<syntaxhighlight lang="c">
// teste ob Bit 0 sowohl in key_state als auch in i gesetzt ist
// und setze Bit 0 in key_press, wenn das der Fall ist
if( ( key_state & ( 1 << 0 ) ) &&
( i & ( 1 << 0 ) )
key_press |= ( 1 << 0 );

// Bit 1
if( ( key_state & ( 1 << 1 ) ) &&
( i & ( 1 << 1 ) )
key_press |= ( 1 << 1 );

// Bit 2
if( ( key_state & ( 1 << 2 ) ) &&
( i & ( 1 << 2 ) )
key_press |= ( 1 << 2 );

...
</syntaxhighlight>
nur als wesentlich kompaktere Operation ausgeführt und für alle 8 Bits gleichzeitig.
Die Kürze und Effizienz dieser paar Codezeilen ergibt sich aus dem Umstand, dass jedes Bit in den Variablen für eine Taste steht und alle 8 (maximal möglichen) Tasten gleichzeitig die Operationen durchlaufen.

===== Reduziert auf lediglich 1 Taste =====
Diskussionen im Forum zeigen immer wieder, dass viele eine Abneigung gegen diesen Code haben, weil er ihnen sehr kompliziert vorkommt.

Der Code ist nicht leicht zu analysieren und er zieht alle Register dessen, was möglich ist, um sowohl Laufzeit als auch Speicherverbrauch einzusparen. Oft hört man auch das Argument: Ich benötige ja nur eine Entprellung für 1 Taste, gibt es da nichts Einfacheres?

Hier ist die 'Langform' des Codes, so wie man das für lediglich 1 Taste schreiben würde, wenn man exakt dasselbe Entprellverfahren einsetzen würde. Man sieht: Da ist keine Hexerei dabei: In key_state wird der letzte bekannte entprellte Zustand der Taste gehalten. Der Pin-Eingang wird mit diesem Zustand verglichen und wenn sich die beiden unterscheiden, dann wird ein Zähler heruntergezählt. Produziert dieses herunterzählen einen Unterlauf des Zählers, dann gilt die Taste als entprellt und wenn dann auch noch die Taste gerade gedrückt ist, dann wird dieses in key_press entsprechend vermerkt.

<syntaxhighlight lang="c">
uint8_t key_state;
uint8_t key_counter;
volatile uint8_t key_press;

ISR( ... Overflow ... )
{
uint8_t input = KEY_PIN & ( 1 << KEY0 );

if( input != key_state ) {
key_counter--;
if( key_counter == 0xFF ) {
key_counter = 3;
key_state = input;
if( input )
key_press = TRUE;
}
}
else
key_counter = 3;

}

uint8_t get_key_press()
{
uint8_t result;

cli();
result = key_press;
key_press = FALSE;
sei();

return result;
}
</syntaxhighlight>

Der vollständige Entprellcode, wie weiter oben gelistet, besticht jetzt aber darin, dass er compiliert kleiner ist als diese anschaulichere Variante für lediglich 1 Taste. Und das bei gleichzeitig erhöhter Funktionalität. Denn zb. ein Autorepeat ist in diesem Code noch gar nicht eingebaut. Und spätestens wenn man dann eine 2.te Taste entprellen möchte, dann ist auch der SRAM-Speicherverbrauch dieser Langform höher als der des Originals für 8 Tasten. Daraus folgt: Selbst für lediglich 1 Taste ist die Originalroutine die bessere Wahl.

Und wegen der Komplexität mal eine Frage: Sind Sie selbst in der Lage eine entsprechend effiziente sqrt() Funktion zu schreiben, wie die, die sie in der Standard-C-Bibliothek vorfinden? Nein? Dann dürften Sie eigentlich Ihrer Argumentation nach die Bibliotheksfunktion sqrt() nicht verwenden, sondern müssten sich statt dessen selbst eine Wurzel-Funktion schreiben.

=== Selbstsättigender Filter (nach Jürgen Schuhmacher) ===
Durch die Nutzung der diskreten Signalanalyse in Software kann die Funktionalität einer einfachen Entprellung mit einem Widerstand, einem Kondensator und einem Schmitttrigger wie in Hardware nachgebildet werden, indem ein abstrakter IIR-Filter benutzt wird, der eine Kondensatorladekurve emuliert. Mit der Vorschrift Y(t) = k Y(t-1) + Input wird ein einfaches Filter erzeugt, dass dem Eingangswert träge folgt. Bei Überschreiten eines bestimmten Wertes erfolgt mit einer einfachen Abfrage das Schalten des Ausgangssignals.

Für Assembler und VHDL bei FPGAs eignet sich aufgrund der leicht zu implementierenden binären Operationen folgende Darstellung mit einer Auflösung des Filterwertspeichers von nur 8 bit: Wert_Neu = Wert_Alt - Wert_Alt/16 + 16*(Taste = True). Der Filterwert bildet dann den gedämpften Verlauf des Eingangs (flankenverschliffen) ab und kann Prellen bis nahe an den Grenzbereich zum schnellen Tasten unterdrücken. Der Ausgangswert ist dann einfach das höchstwertige Bit des Filterwertes.

[[Datei:Entprellung mit IIR-Filter.gif]]

Dazu muss das Signal des Tasters idealerweise um den Faktor 10-20 schneller abgetastet werden, als die höchste gewünschte Tippgeschwindigkeit vorgibt. Noch schneller abzutasten ist möglich, führt aber zu mehr Bedarf an Bits beim Filter. Die Schmittriggerfunktion kann dadurch gebildet werden, dass eine 1 am Ausgang bei z.B. Überschreiten einer 55% Grenze und eine 0 bei Unterschreitung der 45%-Grenze ausgeben wird. Im Zwischenbereich wird der alte Wert gehalten.

=== Einfacher Mittelwertfilter (nach Lothar Miller) ===
Für digitale Schaltungen oder PLDs empfiehlt sich ein FIR-Filter mit aneinandergereihten FlipFlops. Man schiebt das Eingangssignal in eine FlipFlop-Kette und schaltet oberhalb der Mitte um:

SignalInput -> FF1 -> FF2 -> FF3 -> FF4 -> FF5 -> FF6 -> FF7 -> FF8

Wenn alle FFs = 1 (Summe der FFs=8) dann SignalOutput = 1 
Wenn alle FFs = 0 (Summe der FFs=0) dann SignalOutput = 0

Dieses Verfahren kann sehr einfach in Logik abgebildet werden, weil für die Berechnung des Ausgangs nur ein NOR bz. ein AND Gatter nötig ist.

== Gegenüberstellung der Verfahren ==
* HW - "entprellte Schalter": Sehr teuer, grosse Bauform, verschleissbelastet, geringe Haltbarkeit
* HW - "Umschalter" : benötigt aufwändigeren Schalter, benötigt Elektronik
* HW - "Umschalter ohne FF" : benötigt aufwändigeren Schalter und kleiner Kondensator
* HW - "Kondensatorentprellung" : benötigt etwas mehr Platz, kommt mit schlechten Schaltern zurecht

* SW - Flankenverfahren:
* SW - Warteschleife: Durch die Warteschleifen eine nicht zu vernachlässigende Verzögerung im Code. Speziell wenn mehrere Tasten zu überwachen sind, nicht unproblematisch
* SW - Timer: Universalfunktionalität, die durch geringen Speicherverbrauch, geringen Rechenzeitverbrauch und gute Funktion besticht. Der 'Verbrauch' eines Timers sieht auf den ersten Blick schlimmer aus, als er ist, denn in den meisten Programmen hat man sowieso einen Basistimer für die Zeitsteuerung des Programms im Einsatz, der für die Tastenentprellung mitbenutzt werden kann.
* SW - Filter: sehr geringer Platzbedarf in FPGAs, relativ gute Wirkung
* SW - Filter 2: sehr geringer Platzbedarf, gute Wirkung

== Links zum Thema ==

* [http://www.edn.com/design/analog/4324067/Contact-debouncing-algorithm-emulates-Schmitt-trigger Contact-debouncing algorithm (Artikel)], [http://www.edn.com/file/13370-70705di.pdf als PDF]
* [[AVR-Tutorial: Tasten]]
* [[AVR-GCC-Tutorial#.28Tasten-.29Entprellung|AVR-GCC-Tutorial Tastenentprellung]]
* [http://www.mikrocontroller.net/forum/read-4-20435.html Beitrag im Forum, AVR Assembler]
* [http://www.ganssle.com/debouncing.pdf A guide to debouncing (engl.), praktische Erläuterungen zum Entprellen in Soft- und Hardware]
* [http://www.pololu.com/docs/0J16/all Understanding Destructive LC Voltage Spikes]

[[Kategorie:AVR]]
[[Kategorie:Signalverarbeitung]]

AVR und Linux

2014-02-14T09:25:44Z

145.225.60.4:

Was ist zu beachten, wenn man mit einer Linux-Distribution AVRs programmieren möchte? Hier ist eine offene Liste von verschiedenen Tipps dazu...

==Toolchain beschaffen==

Eventuell sind die benötigten Pakete in der verwendeten Distribution enthalten. Einfach mal die Paketnamen und -beschreibungen nach "avr" durchsuchen.

Diese fertigen Pakete sind aber nicht selten mit Vorsicht zu genießen, denn es gibt ein ganz grundsätzliches Problem. Im Prinzip kann man einen avr-gcc "bauen", indem man sich die offiziellen GCC-Quellen besorgt und dann einfach für das Target avr übersetzt. Und in der Tat scheinen die in den Distributionspaketen enthaltenen Compiler nicht selten auf genau diesem Wege entstanden zu sein. Das Problem dabei ist, dass ein solcher avr-gcc niemals vollständig/aktuell ist, denn es gibt immer zusätzliche AVR spezifische Patches, die nicht in den offiziellen GCC-Quellen enthalten sind. Zum einen, weil der jeweilige Patch noch zu neu ist (die Übernahme in die offiziellen Quellen dauert seine Zeit), zum anderen weil er grundsätzlich nicht offiziell übernommen werden kann, da der Autor des Patches kein FSF-Assignment hat.
Ähnliches gilt auch für die weiteren Komponenten der Toolchain, z.B. binutils.

Wer eine Distribution benutzt, die keine AVR-Pakete enthält, oder wer obigem Problem aus dem Weg gehen will, kann sich selber eine Toolchain mit den aktuellen Patches übersetzen. Ziemlich einfach geht das mit einem Skript von Bingo600, das man hier bekommen kann:
* http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=95328 (mit avr-libc 1.7.x)
* http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=42631 (mit avr-libc 1.6.x)

Es gibt auch fertige Deb-Pakete, die auf der Basis dieses Skripts entstanden sind:
* http://www.wrightflyer.co.uk/avr-gcc/

==Editor==

Der Editor sollte das Bearbeiten vom Programm einfach machen. Evtl. nützlich sind Features, um z. B. per Knopfdruck zu kompilieren und das Programm auf den AVR zu übertragen. Ansonsten: Editoren sind Geschmackssache, d.h. ausprobieren. Hier eine Auswahl (alphabetisch):

: [http://www.codeblocks.org/ Codeblocks] [gtk]
: [[AVR_Eclipse|Eclipse]] [http://www.eclipse.org/] [Java]
: [http://www.gnu.org/software/emacs/ Emacs] bzw. [http://www.xemacs.org/ XEmacs] [Textterminal oder X]
: [http://www.geany.org/ Geany] [gtk]
: [http://www.gnome.org/projects/gedit/ gedit] [GNOME]
: [http://kate-editor.org/ kate] [KDE]
: [http://www.kdevelop.org/ KDevelop] [KDE]
: [http://www.cadmaniac.org/projectMain.php?projectName=kontrollerlab Kontrollerlab] [KDE]
: [http://quanta.kdewebdev.org/ Quanta+] [KDE] (eigentlich Webentwicklungsumgebung)
: [http://www.scintilla.org/ SciTE]
: [http://www.sublimetext.com/ Sublime Text 2] (Windows, Linux und OS X)
: [http://www.vim.org/ Vim bzw. GVim] [Textterminal oder X]

Es lassen sich aber Programme auch in 'fremden' Desktopumgebungen ausführen, z.B KDevelop in GNOME.

==C-Compiler: avr-gcc==

Macht aus dem C-Code den vom AVR ausführbaren binären Programmcode.

Siehe auch:
* [[AVR-GCC]]
* [[AVR-GCC-Tutorial]]

==Laufzeitbibliothek: avr-libc==

Enthält Makros und Hardwaredefinitionen wie Registernamen für (die meisten) AVRs. Man muss sich deswegen um die echten Adressen in der Prozessor-Logik nicht mehr selbst kümmern, sondern kann direkt die Namen und Werte aus dem Datenblatt benutzen.

http://www.nongnu.org/avr-libc/user-manual/index.html

==Makefile==

Enthält Informationen zum Kompilieren. Das Programm make startet damit den angegeben Compiler. Im einfachsten Fall muss man also nur '''make all''' im entsprechenden Projektverzeichnis aufrufen, der Rest läuft automatisch. Die Datei heisst einfach nur Makefile.

Hier ein Skript, mit dem man die Einstellungen zusammenklicken kann (benötigt aber auch wieder anderes, z. B. TCL/TK, ..): http://www.sax.de/~joerg/mfile/ Dessen Aufruf erfolgt dann z. B. mit

<pre>
$ wish mfile.tcl
</pre>

Über ein Menü kann man dann die Einstellungen zusammenklicken. Das Editieren des Makefiles für Spezialanpassungen lässt sich aktivieren.

Wer sie von Windows kennt und sucht: Die Definition F_CPU der Taktfrequenz ist in der aktuellen Linux-Version nicht vorgesehen. Macht nichts, siehe dazu http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Taktfrequenz

==Programmierprogramm==

Das Programmierprogramm schreibt mit entsprechender Hardware auf den Mikrocontroller bzw. liest ihn aus. AVR Programmierprogramme unter Linux sind z. B. [[AVRDUDE]] oder [[uisp]].

Mit dem Makefile-Generator mfile kann man das Programmierprogramm und dessen Aufrufzeile in das Makefile eintragen lassen und später z. B. mit ''make program'' starten.

Für eine interaktive Bedienung von AVRDUDE mit einer grafischen Benutzerschnittstelle (GUI) gibt es [http://avr8-burn-o-mat.aaabbb.de/ avr8-burn-o-mat].

Für '''USB-Programmer''' ist die Einstellung der non-root Zugriffsrechte im Artikel [[AVRDUDE#Aufruf_unter_Linux_als_user_.28non-root.29|Aufruf unter Linux als User (non-root)]] beschrieben.

===Fuses, Lockbits===
''(In Bearbeitung)''

Wer bislang Atmels AVR Studio unter Windows zum Programmieren der [[AVR_Fuses]] benutzt hat, kann das z. B. mit dem oben beschriebenen grafischen [[Burn-o-mat|AVR Burn-O-Mat]] oder eben mit AVRDUDE (über die Shell) machen. Wer die Dokumentation sucht, findet sie mit Sicherheit im [http://download.savannah.gnu.org/releases/avrdude/ gepackten Programmpaket].

*TODO: Ein aktuelles PDF

Z.B. bekommt man als Resultat folgenden Aufrufes den Hexwert der lfuse eines Tiny13 über einen [http://www.mikrocontroller.net/articles/AVR_In_System_Programmer AVR-ISP] mit aktueller Firmware, der an einem USB-Seriell-Wandler angeschlossen ist.

Durch die Option -v ([http://en.wiktionary.org/wiki/verbose verbose]) wird aber noch viel mehr [http://www.mikrocontroller.net/forum/read-1-399733.html?#399834 angezeigt].

<pre>
avrdude -p t13 -c avrispv2 -P /dev/ttyUSB0 -v -U lfuse:r:-:i
</pre>

Das '-' anstelle von FILENAME leitet die Ausgabe auf <stdout> (Bildschirm).

Anstelle des 'i' können verwendet werden:
* 'h' - hexadezimal, z.B. 0xdf
* 'o' - oktal, z.B. 0337
* 'b' - binär, z.B. 0b11011111

[Quelle: man avrdude, Beschreibung des Schalters '-U']

*TODO: Frontend?

Eine Anleitung zum Umgang:
http://www.mikrocontroller.net/forum/read-1-152502.html

Eine 0 steht für eine gesetzte Fuse.

Die Bedeutung der Bits findet sich im Datenblatt unter "Memory Programming -> Fuse Bytes" (tiny13).

===Program/Burn Flash===
''(In Bearbeitung)''

Der Mikrocontroller wird wie beim Kompilieren mithilfe von make und der eingestellten Programmiersoftware mit dem Befehl ''make program'' geflasht

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Anwendung

==Konfiguration, Probleme, Erfahrungen==

===Debian===

* Toolchain-Build: http://blog.coldtobi.de/index.php?op=ViewArticle&articleId=21&blogId=1

==== Etch (Netinst) ====
* Installation: gcc-avr, libc-avr, avrdude aus Standardquellen
* Emacs21 als Editor
* Makefile
... läuft problemlos.

===Gentoo===
Gentoo bietet mit dem Shellscript "crossdev" eine einfache automatisierte Möglichkeit die Toolchain zu erstellen. Genauere Versionen von binutils/gcc/libc können via parameter übergeben werden.
<pre>
emerge crossdev
crossdev --target avr
</pre>
Falls 'crossdev --target avr' nicht fehlerfrei durchlaufen sollte mit 'crossdev -t avr --without-headers' versuchen (2009-01-28).

crossdev ist nich empfehlenswert, da anscheinend ein compiler erstellt wird ohne passende patches. Das kann zu problemen führen, muss aber nicht, z.B. kann der , damit erstellte, gcc keine 64bit werte verarbeiten.

===Mandrake===

* Toolchain-Build: http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=42631
* 2007: benötigt "texinfo" Package

===openSUSE===

* Halbwegs aktuelle RPMs für openSUSE gibt es unter http://download.opensuse.org/repositories/CrossToolchain:/avr/ . Entsprechend der verwendeten openSUSE-Version das jeweilige Verzeichnis als Repository zu yast hinzufuegen (Achtung: Pfade fuer gcc-Binaries sind unterschiedlich zu den von openSUSE normalerweise mitgebrachten Paketen!).

===Ubuntu 6.06===

* Pakete veraltet; ist bereits als bug gemeldet
* Toolchain selbst kompilieren:
** default system path steht in /etc/environment
** Toolchain-Build: http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=42631

===Ubuntu 7.04===

* Toolchain-Build: http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=42631

===Ubuntu 8.04===
* einfach eine universe-Paketquelle von Ubuntu 8.10 (Intrepid Ibex) hinzufügen. Dort gibt es dann aktuelle AVR-Pakete (gcc 4.3, libc 1.6.2 usw.). Anleitung hier: http://packages.ubuntu.com/de/intrepid/i386/gcc-avr/download

===Ubuntu neuer===
* Die Pakete sind im Paketmanagement System schon enthalten. Ein "sudo apt-get install gcc-avr avr-libc" installiert sie.

===rCOS LiveCD===

Die [http://wiki.rcos.eu/index.php/RCOS-LiveCD rCOS LiveCD] (Download: http://www.rcos.eu/tools/livecd/index.html) ist eine angenehm schlanke Debian-LiveCD mit etlichen installierten Toolchains ([[AVR]], [[ARM]], [[Cortex-M3]], ...) extra für die µC Arbeit. Auf der LiveCD befindet sich auch ein [[AVRDUDE]] v5.5.

===Arch Linux===
installation mittels: pacman -S avr-binutils avr-gcc avr-gdb avr-libc avrdude

[[Category:AVR]]
[[Kategorie:Linux]]
[[Kategorie:Entwicklungstools]]

AVR-Tutorial: Interrupts

2014-02-14T09:23:05Z

145.225.60.4:

==Definition==

Bei bestimmten Ereignissen in Prozessoren wird ein sogenannter '''Interrupt''' ausgelöst. Interrupts machen es möglich, beim Eintreten eines Ereignisses sofort informiert zu werden, ohne permanent irgendeinen Status abzufragen, was teure Rechenzeit kosten würde. Dabei wird das Programm unterbrochen und ein Unterprogramm aufgerufen. Wenn dieses beendet ist, läuft das Hauptprogramm ganz normal weiter.

==Mögliche Auslöser==

Bei Mikrocontrollern werden Interrupts z. B. ausgelöst wenn:

* sich der an einem bestimmten Eingangs-Pin anliegende Wert von High auf Low ändert (oder umgekehrt)
* eine vorher festgelegte Zeitspanne abgelaufen ist ([[Timer]])
* eine serielle Übertragung abgeschlossen ist ([[UART]])
* ...

Der ATmega8 besitzt 18 verschiedene Interruptquellen. Standardmäßig sind diese alle deaktiviert und müssen über verschiedene IO-Register einzeln eingeschaltet werden.

==INT0, INT1 und die zugehörigen Register==

Wir wollen uns hier erst mal die beiden Interrupts '''INT0''' und '''INT1''' anschauen. INT0 wird ausgelöst, wenn sich der an PD2 anliegende Wert ändert, INT1 reagiert auf Änderungen an PD3.

Als erstes müssen wir die beiden Interrupts konfigurieren. Im Register '''MCUCR''' wird eingestellt, ob die Interrupts bei einer steigenden Flanke (low nach high) oder bei einer fallenden Flanke (high nach low) ausgelöst werden. Dafür gibt es in diesem Register die Bits '''ISC00''', '''ISC01''' (betreffen INT0) und '''ISC10''' und '''ISC11''' (betreffen INT1).

Hier eine Übersicht über die möglichen Einstellungen und was sie bewirken:

<center>
{| {{Tabelle}}
|- style="background-color:#ffddcc"
! ISC11 o. ISC01 || ISC10 o. ISC00 ||Beschreibung
|-
|align="center" | 0
|align="center" | 0
||Low-Level am Pin löst den Interrupt aus
|-
|align="center" | 0
|align="center" | 1
||Jede Änderung am Pin löst den Interrupt aus
|-
|align="center" | 1
|align="center" | 0
||Eine fallende Flanke löst den Interrupt aus
|-
|align="center" | 1
|align="center" | 1
||Eine steigende Flanke löst den Interrupt aus
|-
|}
</center>

Danach müssen diese beiden Interrupts aktiviert werden, indem die Bits '''INT0''' und '''INT1''' im Register '''GICR''' auf '''1''' gesetzt werden.

Die Register '''MCUCR''' und '''GICR''' gehören zwar zu den IO-Registern, können aber nicht wie andere mit den Befehlen '''cbi''' und '''sbi''' verwendet werden. Diese Befehle wirken nur auf die IO-Register bis zur Adresse 0x1F (welches Register sich an welcher IO-Adresse befindet, steht in der Include-Datei, hier "m8def.inc", und im Datenblatt des Controllers). Somit bleiben zum Zugriff auf diese Register nur die Befehle '''in''' und '''out''' übrig.

==Interrupts generell zulassen==

Schließlich muss man noch das Ausführen von Interrupts allgemein aktivieren, was man durch einfaches Aufrufen des Assemblerbefehls '''sei''' bewerkstelligt.

==Die Interruptvektoren==

Woher weiß der Controller jetzt, welche Routine aufgerufen werden muss wenn ein Interrupt ausgelöst wird?

Wenn ein Interrupt auftritt, dann springt die Programmausführung an eine bestimmte Stelle im Programmspeicher. Diese Stellen sind festgelegt und können nicht geändert werden:

<center>
{| {{Tabelle}}
|- style="background-color:#ffddcc"
! Nr. || Adresse || Interruptname || Beschreibung
|-
|align="center" | 1
|align="center" | 0x000
|align="center" | RESET
||Reset bzw. Einschalten der Stromversorgung
|-
|align="center" | 2
|align="center" | 0x001
|align="center" | INT0
||Externer Interrupt 0
|-
|align="center" | 3
|align="center" | 0x002
|align="center" | INT1
||Externer Interrupt 1
|-
|align="center" | 4
|align="center" | 0x003
|align="center" | TIMER2_COMP
||Timer/Counter2 Compare Match
|-
|align="center" | 5
|align="center" | 0x004
|align="center" | TIMER2_OVF
||Timer/Counter2 Overflow
|-
|align="center" | 6
|align="center" | 0x005
|align="center" | TIMER1_CAPT
||Timer/Counter1 Capture Event
|-
|align="center" | 7
|align="center" | 0x006
|align="center" | TIMER1_COMPA
||Timer/Counter1 Compare Match A
|-
|align="center" | 8
|align="center" | 0x007
|align="center" | TIMER1_COMPB
||Timer/Counter1 Compare Match B
|-
|align="center" | 9
|align="center" | 0x008
|align="center" | TIMER1_OVF
||Timer/Counter1 Overflow
|-
|align="center" | 10
|align="center" | 0x009
|align="center" | TIMER0_OVF
||Timer/Counter0 Overflow
|-
|align="center" | 11
|align="center" | 0x00A
|align="center" | SPI_STC
||SPI-Übertragung abgeschlossen
|-
|align="center" | 12
|align="center" | 0x00B
|align="center" | USART_RX
||USART-Empfang abgeschlossen
|-
|align="center" | 13
|align="center" | 0x00C
|align="center" | USART_UDRE
||USART-Datenregister leer
|-
|align="center" | 14
|align="center" | 0x00D
|align="center" | USART_TX
||USART-Sendung abgeschlossen
|-
|align="center" | 15
|align="center" | 0x00E
|align="center" | ADC
||AD-Wandlung abgeschlossen
|-
|align="center" | 16
|align="center" | 0x00F
|align="center" | EE_RDY
||EEPROM bereit
|-
|align="center" | 17
|align="center" | 0x010
|align="center" | ANA_COMP
||Analogkomparator
|-
|align="center" | 18
|align="center" | 0x011
|align="center" | TWI
||Two-Wire Interface
|-
|align="center" | 19
|align="center" | 0x012
|align="center" | SPM_RDY
||Store Program Memory Ready
|}
</center>

So, wir wissen jetzt, dass der Controller zu Adresse 0x001 springt, wenn '''INT0''' auftritt. Aber dort ist ja nur Platz für einen Befehl, denn die nächste Adresse ist doch für INT1 reserviert. Wie geht das? Ganz einfach: Dort kommt ein Sprungbefehl rein, z. B. '''rjmp interrupt0'''. Irgendwo anders im Programm muss in diesem Fall eine Stelle mit interrupt0: gekennzeichnet sein, zu der dann gesprungen wird. Diese durch den Interrupt aufgerufene Routine nennt man '''Interrupthandler''' (engl. '''I'''nterrupt '''S'''ervice '''R'''outine, '''ISR''').

==Beenden eines Interrupthandlers==

Und wie wird die Interruptroutine wieder beendet? Durch den Befehl '''reti'''. Wird dieser aufgerufen, dann wird das Programm ganz normal dort fortgesetzt, wo es durch den Interrupt unterbrochen wurde. Es ist dabei wichtig, daß hier der Befehl '''reti''' und nicht ein normaler '''ret''' benutzt wird. Wird ein Interrupt Handler betreten, so sperrt der Mikrocontroller automatisch alle weiteren Interrupts. Im Unterschied zu '''ret''', hebt ein '''reti''' diese Sperre wieder auf.

==Aufbau der Interruptvektortabelle==

Jetzt müssen wir dem Assembler nur noch klarmachen, dass er unser '''rjmp interrupt0''' an die richtige Stelle im Programmspeicher schreibt, nämlich an den Interruptvektor für '''INT0'''. Dazu gibt es eine Assemblerdirektive. Durch '''.org 0x001''' sagt man dem Assembler, dass er die darauffolgenden Befehle ab Adresse 0x001 im Programmspeicher platzieren soll. Diese Stelle wird von '''INT0''' angesprungen.

Damit man nicht alle Interruptvektoren immer nachschlagen muss, sind in der Definitionsdatei m8def.inc einfach zu merkende Namen für die Adressen definiert. Statt 0x001 kann man z. B. einfach '''INT0addr''' schreiben. Das hat außerdem den Vorteil, dass man bei Portierung des Programms auf einen anderen AVR-Mikrocontroller nur die passende Definitionsdatei einbinden muss, und sich über evtl. geänderte Adressen für die Interruptvektoren keine Gedanken zu machen braucht.

Nun gibt es nur noch ein Problem: Beim Reset (bzw. wenn die Spannung eingeschaltet wird) wird das Programm immer ab der Adresse 0x000 gestartet. Deswegen muss an diese Stelle ein Sprungbefehl zum Hauptprogramm erfolgen, z. B. '''rjmp RESET''' um an die mit '''RESET:''' markierte Stelle zu springen.

Wenn man mehrere Interrupts verwenden möchte, kann man auch, anstatt jeden Interruptvektor einzeln mit .org an die richtige Stelle zu rücken, die gesamte Sprungtabelle ausschreiben:

<syntaxhighlight lang="avrasm">
.include "m8def.inc"

.org 0x000 ; kommt ganz an den Anfang des Speichers
rjmp RESET ; Interruptvektoren überspringen
; und zum Hauptprogramm
rjmp EXT_INT0 ; IRQ0 Handler
rjmp EXT_INT1 ; IRQ1 Handler
rjmp TIM2_COMP
rjmp TIM2_OVF
rjmp TIM1_CAPT ; Timer1 Capture Handler
rjmp TIM1_COMPA ; Timer1 CompareA Handler
rjmp TIM1_COMPB ; Timer1 CompareB Handler
rjmp TIM1_OVF ; Timer1 Overflow Handler
rjmp TIM0_OVF ; Timer0 Overflow Handler
rjmp SPI_STC ; SPI Transfer Complete Handler
rjmp USART_RXC ; USART RX Complete Handler
rjmp USART_DRE ; UDR Empty Handler
rjmp USART_TXC ; USART TX Complete Handler
rjmp ADC ; ADC Conversion Complete Interrupthandler
rjmp EE_RDY ; EEPROM Ready Handler
rjmp ANA_COMP ; Analog Comparator Handler
rjmp TWSI ; Two-wire Serial Interface Handler
rjmp SPM_RDY ; Store Program Memory Ready Handler

RESET: ; hier beginnt das Hauptprogramm
</syntaxhighlight>

Hier ist es unbedingt nötig, bei unbenutzten Interruptvektoren statt des Sprungbefehls den Befehl '''reti''' (bzw. '''reti nop''', wenn jmp 4 Byte lang ist) reinzuschreiben. Wenn man einen Vektor einfach weglässt stehen die nachfolgenden Sprungbefehle sonst alle an der falschen Adresse im Speicher.

Wer auf Nummer sicher gehen möchte kann aber auch alle Vektoren einzeln mit .org adressieren:

<syntaxhighlight lang="avrasm">
.include "m8def.inc"

.org 0x000
rjmp RESET
.org INT0addr ; External Interrupt0 Vector Address
reti
.org INT1addr ; External Interrupt1 Vector Address
reti
.org OC2addr ; Output Compare2 Interrupt Vector Address
reti
.org OVF2addr ; Overflow2 Interrupt Vector Address
reti
.org ICP1addr ; Input Capture1 Interrupt Vector Address
reti
.org OC1Aaddr ; Output Compare1A Interrupt Vector Address
reti
.org OC1Baddr ; Output Compare1B Interrupt Vector Address
reti
.org OVF1addr ; Overflow1 Interrupt Vector Address
reti
.org OVF0addr ; Overflow0 Interrupt Vector Address
reti
.org SPIaddr ; SPI Interrupt Vector Address
reti
.org URXCaddr ; USART Receive Complete Interrupt Vector Address
reti
.org UDREaddr ; USART Data Register Empty Interrupt Vector Address
reti
.org UTXCaddr ; USART Transmit Complete Interrupt Vector Address
reti
.org ADCCaddr ; ADC Interrupt Vector Address
reti
.org ERDYaddr ; EEPROM Interrupt Vector Address
reti
.org ACIaddr ; Analog Comparator Interrupt Vector Address
reti
.org TWIaddr ; Irq. vector address for Two-Wire Interface
reti
.org SPMRaddr ; SPM complete Interrupt Vector Address
reti

.org INT_VECTORS_SIZE
RESET: ; hier beginnt das Hauptprogramm
</syntaxhighlight>

Statt die unbenutzten Interruptvektoren mit '''reti''' zu füllen könnte man sie hier auch einfach weglassen, da die '''.org'''-Direktive dafür sorgt dass jeder Vektor in jedem Fall am richtigen Ort im Speicher landet.

==Beispiel==
So könnte ein Minimal-Assemblerprogramm aussehen, das die Interrupts INT0 und INT1 verwendet. An die Interrupt Pins können zb Taster nach bewährter Manier angeschlossen werden. Die Interrupts werden auf fallende Flanke konfiguriert, da ja die Taster so angeschlossen sind, dass sie im Ruhezustand eine 1 liefern und bei einem Tastendruck nach 0 wechseln.

[http://www.mikrocontroller.net/sourcecode/tutorial/extinttest.asm Download extinttest.asm]

<syntaxhighlight lang="avrasm">
.include "m8def.inc"

.def temp = r16

.org 0x000
rjmp main ; Reset Handler
.org INT0addr
rjmp int0_handler ; IRQ0 Handler
.org INT1addr
rjmp int1_handler ; IRQ1 Handler

main: ; hier beginnt das Hauptprogramm

ldi temp, LOW(RAMEND)
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

ldi temp, 0x00
out DDRD, temp

ldi temp, 0xFF
out DDRB, temp

ldi temp, (1<<ISC01) | (1<<ISC11) ; INT0 und INT1 auf fallende Flanke konfigurieren
out MCUCR, temp

ldi temp, (1<<INT0) | (1<<INT1) ; INT0 und INT1 aktivieren
out GICR, temp

sei ; Interrupts allgemein aktivieren

loop: rjmp loop ; eine leere Endlosschleife

int0_handler:
sbi PORTB, 0
reti

int1_handler:
cbi PORTB, 0
reti
</syntaxhighlight>

Für dieses Programm braucht man nichts weiter als eine LED an PB0 und je einen Taster an PD2 (INT0) und PD3 (INT1). Wie diese angeschlossen werden, steht in [[AVR-Tutorial: IO-Grundlagen|Teil 2]] des Tutorials.

Die Funktion ist auch nicht schwer zu verstehen: Drückt man eine Taste, wird der dazugehörige Interrupt aufgerufen und die LED an- oder abgeschaltet. Das ist zwar nicht sonderlich spektakulär, aber das Prinzip sollte deutlich werden.

Meistens macht es keinen Sinn, Taster direkt an einen Interrupteingang anzuschließen. Das kann bisweilen sogar sehr schlecht sein, siehe [[Entprellung]]. Häufiger werden Interrupts in Zusammenhang mit dem UART verwendet, um z. B. auf ein empfangenes Zeichen zu reagieren. Wie das funktioniert, wird im Kapitel über den [[AVR-Tutorial:_UART|UART]] beschrieben.

==Besonderheiten des Interrupthandlers==

Der Interrupthandler kann ja mehr oder weniger zu jedem beliebigen Zeitpunkt unabhängig vom restlichen Programm aufgerufen werden. Dabei soll das restliche Programm auf keinen Fall durch den Interrupthandler negativ beeinflusst werden, das heißt das Hauptprogramm soll nach dem Beenden des Handlers weiterlaufen als wäre nichts passiert. Insbesondere muss deshalb darauf geachtet werden, dass im Interrupthandler Register, die vom Programmierer nicht ausschließlich nur für den Interrupthandler reserviert wurden, auf dem Stack gesichert und zum Schluss wieder hergestellt werden müssen.

Ein Register, das gerne übersehen wird, ist das '''Status Register'''. In ihm merkt sich der Prozessor bestimmte Zustände von Berechnungen, z. B. ob ein arithmetischer Überlauf stattgefunden hat, ob das letzte Rechenergebnis 0 war, etc. Sobald ein Interrupthandler etwas komplizierter wird als im obigen Beispiel, tut man gut daran, das '''SREG''' Register auf jeden Fall zu sichern. Ansonsten kann das Hinzufügen von weiterem Code zum Interrupthandler schnell zum Boomerang werden: Die dann möglicherweise notwendige Sicherung des '''SREG''' Registers wird vergessen. Überhaupt empfiehlt es sich, in diesen Dingen bei der Programmierung eines Interrupthandlers eher vorausschauend, übervorsichtig und konservativ zu programmieren. Wird dies getan, so vergeudet man höchstens ein bischen Rechenzeit. Im anderen Fall handelt man sich allerdings einen Super-GAU ein: Man steht dann vor einem Programm, das sporadisch nicht funktioniert und keiner weiss warum. Solche Fehler sind nur sehr schwer und oft nur mit einem Quäntchen Glück zu finden.

Im Beispiel wäre zwar das Sichern und Wiederherstellen der Register '''temp''' und '''SREG''' nicht wirklich notwendig, aber hier soll die grundsätzliche Vorgehensweise gezeigt werden:

<syntaxhighlight lang="avrasm">
.include "m8def.inc"

.def temp = r16

.org 0x000
rjmp main ; Reset Handler
.org INT0addr
rjmp int0_handler ; IRQ0 Handler
.org INT1addr
rjmp int1_handler ; IRQ1 Handler

main: ; hier beginnt das Hauptprogramm

ldi temp, LOW(RAMEND)
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

ldi temp, 0x00
out DDRD, temp

ldi temp, 0xFF
out DDRB, temp

ldi temp, (1<<ISC01) | (1<<ISC11) ; INT0 und INT1 auf fallende Flanke konfigurieren
out MCUCR, temp

ldi temp, (1<<INT0) | (1<<INT1) ; INT0 und INT1 aktivieren
out GICR, temp

sei ; Interrupts allgemein aktivieren

loop: rjmp loop ; eine leere Endlosschleife

int0_handler:
push temp ; Das SREG in temp sichern. Vorher
in temp, SREG ; muss natürlich temp gesichert werden

sbi PORTB, 0

out SREG, temp ; Die Register SREG und temp wieder
pop temp ; herstellen
reti

int1_handler:
push temp ; Das SREG in temp sichern. Vorher
in temp, SREG ; muss natürlich temp gesichert werden

cbi PORTB, 0

out SREG, temp ; Die Register SREG und temp wieder
pop temp ; herstellen
reti
</syntaxhighlight>

==Siehe auch==
[[Interrupt | Interrupt: Anderer Wiki-Artikel über Interrupts]]

----

{{Navigation_zurückhochvor|
zurücktext=LCD|
zurücklink=AVR-Tutorial: LCD|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Vergleiche|
vorlink=AVR-Tutorial:_Vergleiche}}

[[Category:AVR-Tutorial|Interrupts]]

I²C

2014-02-03T11:49:27Z

145.225.60.4:

'''I²C''' ist ein synchroner serieller Zweidraht-[[Bus]] (eine Daten- und eine Taktleitung), der für die Kommunikation zwischen [[IC]]s über kleine Distanzen geeignet ist. Entwickelt wurde er Anfang der 80er Jahre von Philips.
Gesprochen "I quadrat C" steht für IIC = Inter [[IC]] Bus. Aus Lizenzgründen heißt der I²C Bus bei manchen Herstellern auch '''TWI''', two wire interface.

== I2C ==
In einem I²C-Bus gibt es mindestens einen Master mit bis zu 127 Slaves und einen Broadcast Kanal. Ein I²C-Bus mit mehreren Mastern wird als "Multi-Master-Bus" bezeichnet.
Der (oder die) Master sprechen die Slaves an; ein Slave kann NIE selbstständig Daten senden. Dazu übernimmt der Master, der Daten senden oder empfangen möchte, den Bus und gibt die (7-bit- bzw. 10-bit-)Adresse des Slaves aus, mit dem er kommunizieren möchte. Nach der Adresse teilt der Master dem entsprechenden Slave mit, ob er Daten senden oder empfangen möchte. Danach werden die eigentlichen Daten (entweder vom Master oder Slave) auf den Bus gelegt. Hat der Master den Lese- oder Schreibvorgang abgeschlossen, so gibt er den Bus wieder frei.
Sofern mehrere Master vorhanden sind, stellt ein Protokoll sicher, dass sich diese nicht gegenseitig stören.

=== I2C - Übertragungsraten ===
Die Übertragungsrate beträgt beim standard mode bis zu 100 kbit/s, beim fast mode bis zu 400 kbit/s und beim high-speed mode bis zu 3,4 MBit/s. Falls die Taktrate für einen Slave zu hoch ist, kann er die Clock-Leitung auf Null ziehen und die Übertragung damit verlangsamen (sog. Clock Stretching). Dies ist auf Bit- wie auf Byte-Ebene möglich; ersteres allerdings nicht im high-speed mode.
Um längere Übertragungswege zu realisieren, kann man die Taktrate fast beliebig vermindern (einige Bausteine erzeugen aber irgendwann ein Time-Out). Mit einer Taktfrequenz von nur 5 kbit/s können dann durchaus mehrere Meter überbrückt werden.

Im PC wird ein dem I²C-Bus sehr ähnliches System benutzt, um z. B. die Daten eines [[SDRAM]]-Modules auszulesen. Dieser nennt sich [[SMBus]] (System Management Bus).

Erfahrungen mit den Atmegas (gemessene I2C-Taktfrequenzen):
* 16,000MHz - schafft sauber bis zu 700KHz
* 18,432MHz - schafft sauber bis zu 950KHz

Selbst unter schlechten Bedingungen wie...
* 50cm 6-adriges Spiralkabel, frei schwingend verbaut in einem Rennwagen als Verbindung zwischen Lenkraddisplay und Amaturenbrett
* Nähe zu nicht geschirmten Leitungen mit 12V, GND und 5V PWM zum Dimmen von LEDs
* grausamen Umgebungsbedingungen, Fahrten im Regen, Schnee oder bei glühender Sonne und gefühlten 100° C ;-) auf der Rennstrecke.
hat der Bus ohne Probleme funktioniert.

=== Bausteine ===

Neben Mikrocontrollern gibt es eine Reihe von Peripheriebausteinen, die per I²C angeschlossen werden können. Eine gute Anlaufstelle bei der Suche ist die unten angegebene Seite des "Erfinders" Philips, heute als [http://www.nxp.com NXP] bekannt.

*serielle [[Speicher#EEPROM | EEPROM]]s
** [http://www.datasheetcatalog.net/cgi-bin/helo.pl?text=24C01&action=Search 24Cxx]
** [http://ics.nxp.com/products/pcf/seeproms/ PCF85xx von NXP, 256-2048 Byte]

*I/O-Portexpander
** [[Port-Expander_PCF8574|PCF8574]]
** [http://www.mikrocontroller.net/part/MCP23008 MCP23008] (8-bit) von Microchip
** [http://www.mikrocontroller.net/part/MCP23017 MCP23017](16-bit) von Microchip

* I2C MUX, zum Anschluss von ICs mit gleicher, fester Adresse
** [http://www.datasheetcatalog.org/cgi-bin/helo.pl?field=Nume&type=C&text=PCA9545A&producedby=&action=Search PCA9545A]

* [[AD-Wandler]]
** [http://www.mikrocontroller.net/topic/182614 12x12 Bit ADC MAX1238]
** [http://www.mikrocontroller.net/topic/182614 12x10 Bit ADC MAX1138]
** [http://www.maxim-ic.com/datasheet/index.mvp/id/1890 MAX127 und MAX128 von Maxim, 12bit x8, PDIP24+SSOP28]
** [http://www.jtronics.de/platinen.html 12x8 Bit ADC MAX1038]

* [[DA-Wandler]]
** [http://www.datasheetcatalog.net/cgi-bin/helo.pl?field=Nume&type=C&text=TDA8444&producedby=&action=Search TDA8444, 8x6Bit]

* Uhrenbausteine
** [http://www.datasheetcatalog.net/cgi-bin/helo.pl?field=Nume&type=C&text=PCF8583&producedby=&action=Search PCF8583, mit 256 Bytes RAM]
** DS1307

* [[LCD]]-Treiber
** [http://www.datasheetcatalog.net/cgi-bin/helo.pl?field=Nume&type=C&text=PCF8577&producedby=&action=Search PCF8577, 2x32 Segmente]

* [[Temperatursensor|Temperatursensoren]]
** [http://www.datasheetcatalog.net/cgi-bin/helo.pl?text=DS1621&action=Search DS1621]
** [http://www.datasheetcatalog.net/cgi-bin/helo.pl?text=lm75&action=Search LM75]
** [http://www.sensirion.com/en/pdf/product_information/Datasheet-humidity-sensor-SHT21.pdf SHT21]
** TMP101 von TexasInstruments
** TMP175 von TI (mehr als 8 Bausteine im gleichen Bus möglich)

* Drucksensoren
** SMD500
** BMP085

* Beschleunigungssensor
** [http://www.mikrocontroller.net/articles/BMA020 BMA020]

=== Galvanische Trennung ===
* http://www.analog.com/static/imported-files/application_notes/AN_913.pdf
* http://www.analog.com/en/interface/digital-isolators/products/index.html#Isolated_I2C_Isolators
* http://www.silabs.com/Support%20Documents/TechnicalDocs/Si840x.pdf
* http://www.silabs.com/applications/industrial/Pages/i2c-isolation.aspx
* http://www.mikrocontroller.net/attachment/5670/Galvanische_Trennung_fuer_I2C-Bus.pdf
* http://www.esacademy.com/en/library/technical-articles-and-documents/miscellaneous/i2c-bus/frequently-asked-questions/i2c-faq.html
* http://www.mikrocontroller.net/topic/17425#125464

== Siehe auch ==
* [[AT91-TWI]]
* [[AVR TWI]]
* [[I2C als Hausbus]]
* Beitrag zu [http://www.mikrocontroller.net/topic/181115#1748880 I2C-Adressen] im Forum

== Weblinks ==
* [http://ics.nxp.com/interface/ NXP (ehemals Philips) Produktseite]
* [http://www.nxp.com/acrobat/usermanuals/UM10204_3.pdf I2C Spezifikation 3.0]
* [http://www.i2c-bus.org I²C FAQ, Einführung, Hintergrundinformationen]
* [http://www.robotikhardware.de/download/rn_pc_i2c.pdf robotikhardware.de]
* [http://www.elektronikwissen.net/pegelwandler/7-bidirektionaler-levelshifter-fuer-i2c.html Betrieb von 3V3 und 5V-Bausteinen am I2C-Bus]

=== Bibliotheken ===
* [http://www.jtronics.de/avr-projekte.html AVR TWI Slave]
* [http://www.mikrocontroller.net/topic/235733#2398750 TWI MASTER in ASM]
* [http://homepage.hispeed.ch/peterfleury/avr-software.html AVR TWI/I2C MASTER in C]
* [http://www.mikrocontroller.net/topic/87597 AVR TWI Master und Slave Funtionen in C]
* [http://www.mikrocontroller.net/topic/266642 universelle I2C Master Prozedur für AVR]
* [http://www.mikrocontroller.net/topic/103600 I2C (TWI) Sniffer mit AVR]

===I²C-Interface===
* [http://www.mikrocontroller.net/topic/155136#1462320 Beitrag "i2c usb interface"] (Linux)
* [http://sprut.de/electronic/pic/projekte/usb4all/usb4all.htm USB4ALL bei sprut.de] universeller USB-Baustein, auch für I2C

===I²C-Monitor===
*http://realterm.sourceforge.net/#I2C%20Bus
*http://www.avrfreaks.net/index.php?module=FreaksTools&func=viewItem&item_id=411
* [http://www.telos.info/ConniiMM20 Connii MM 2.0 - I²C Monitor with USB Interface]
* [http://www.telos.info/traciixl20 Tracii XL - High-End I²C Monitor]
*http://i2cchip.com/
* [http://www.ullihome.de/index.php/Hauptseite#USB_AVR-Lab I2C Logger Firmware für USB AVR-ISP]
* [http://www.mikrocontroller.net/topic/41535 I2C Monitor mit Mega8 (Firmware)]
* [http://warmcat.com/milksop/cheapi2c.html Cheapi2c] by Numbnut (Andy Green) uses your PC CPU (Linux only!) and printer port to perform realtime snooping of a standard 100kHz I2C bus with 100% capture.
* [http://www.mikrocontroller.net/topic/103600#905495 I2C (TWI) Sniffer]. Basierend auf einem ATtiny85 mit Ausgabe auf RS232 (C und ASM).
* [http://en.radzio.dxp.pl/i2c-sniffer/ I2C/TWI bus sniffer/analyzer] (ATTiny2313 @ 20 MHz und USB über FTDI FT245RL oder UM245R)
* [http://www.i2cchip.com/start_bit_detector1.jpg I2C Startbit-Detector] auf [http://www.i2cchip.com/ www.i2cchip.com]
* [http://www.harbaum.org/till/i2c_tiny_usb/index.shtml i2c-tiny-usb open source/open hardware zum Auslesen mit einem PC]

[[Category:I2C| ]]

AVR-GCC-Tutorial/LCD-Ansteuerung

2013-12-04T13:51:06Z

145.225.60.4:

==Das LCD und sein Controller==

Die meisten Text-LCDs verwenden den Controller [[HD44780]] oder einen kompatiblen (z. B. KS0070) und haben 14 oder 16 Pins. Hier ist die häufigste Anschluss-Belegung angegeben.

;Achtung: Es gibt Displays mit abweichender Anschluss-Belegung, z.B. TC1602E (Pollin 120420). Falscher Anschluss kann zur Zerstörung führen! Daher immer das zugehörige Datenblatt zu Rate ziehen. Einzelheiten unter Artikel zum Controller [[HD44780]].

{| class="wikitable"
! Pin # || Bezeichnung || Funktion
|-
! 1
| Vss || GND (beim TC1602E Vdd=Vcc)
|-
! 2
| Vdd/Vcc || 5V (beim TC1602E Vss=Gnd)
|-
! 3
| Vee || Kontrastspannung (0V bis 5V)
|-
! 4
| RS || Register Select (Befehle/Daten)
|-
! 5
| RW || Read/Write
|-
! 6
| E
| Enable
|-
! 7
| DB0 ||rowspan="8"| Datenbits 0−7
|-
! 8
| DB1
|-
! 9
| DB2
|-
! 10
| DB3
|-
! 11
| DB4
|-
! 12
| DB5
|-
! 13
| DB6
|-
! 14
| DB7
|-
! 15
| A || LED-Beleuchtung, Anode
|-
! 16
| K || LED-Beleuchtung, Kathode
|}

{{Warnung|
;Achtung: Unbedingt von der richtigen Seite zu zählen anfangen! Meistens ist neben Pin 1 eine kleine 1 auf der LCD-Platine. Ansonsten im Datenblatt nachschauen! Oft ist Pin 1 auch durch ein rechteckiges statt rundes Pad gekennzeichnet.

:Bei LCDs mit 16-poligem Anschluss sind die beiden letzten Pins für die Hintergrundbeleuchtung reserviert. Hier unbedingt das Datenblatt zu Rate ziehen, die beiden Anschlüsse sind je nach Hersteller oft anders beschaltet. Falls kein Datenblatt vorliegt, kann man mit einem Durchgangsprüfer feststellen, welcher Anschluss mit Masse (GND) verbunden ist.
}}

Vss wird ganz einfach an GND angeschlossen und Vcc an 5V. Vee kann man testweise auch an GND legen. Wenn das LCD dann zu dunkel sein sollte muss man ein 10k-Potentiometer zwischen GND und 5V schalten, mit dem Schleifer an Vee:

[[Bild:LCD_Vee.gif]]

Es gibt zwei verschiedene Möglichkeiten zur Ansteuerung eines solchen Displays: den '''8-bit-''' und den '''4-bit-'''Modus.
* Für den '''8-bit-Modus''' werden (wie der Name schon sagt) alle acht Datenleitungen zur Ansteuerung verwendet, somit kann durch einen Zugriff immer ein ganzes Byte übertragen werden.
* Der '''4-bit-Modus''' verwendet nur die oberen vier Datenleitungen ('''DB4-DB7'''). Um ein Byte zu übertragen braucht man somit zwei Zugriffe, wobei zuerst das höherwertige '''"Nibble"''' (= 4 Bits), also Bit 4 bis Bit 7 übertragen wird und dann das niederwertige, also Bit 0 bis Bit 3. Die unteren Datenleitungen des LCDs, die beim Lesezyklus Ausgänge sind, lässt man offen (siehe Datasheets, z. B. vom KS0070).

Der 4-bit-Modus hat den Vorteil, dass man 4 IO-Pins weniger benötigt als beim 8-bit-Modus, weshalb ich mich hier für eine Ansteuerung mit 4bit entschieden habe.

Neben den vier Datenleitungen (DB4, DB5, DB6 und DB7) werden noch die Anschlüsse '''RS''', '''RW''' und '''E''' (ist in manchen Unterlagen auch '''EN''' für ''Enable'' abgekürzt) benötigt.

* Über '''RS''' wird ausgewählt, ob man einen Befehl oder ein Datenbyte an das LCD schicken möchte. Ist RS Low, dann wird das ankommende Byte als Befehl interpretiert, ist RS high, dann wird das Byte auf dem LCD angezeigt.
* '''RW''' legt fest, ob geschrieben oder gelesen werden soll. High bedeutet lesen, low bedeutet schreiben. Wenn man RW auf lesen einstellt und RS auf Befehl, dann kann man das '''Busy-Flag''' an DB7 lesen, das anzeigt, ob das LCD den vorhergehenden Befehl fertig verarbeitetet hat (diese Methode u.a. in der LCD-Library von Peter Fleury verwendet). Ist RS auf Daten eingestellt, dann kann man z. B. den Inhalt des Displays lesen - was jedoch nur in den wenigsten Fällen Sinn macht. Deshalb kann man RW dauerhaft auf low lassen (= an GND anschließen), so dass man noch ein IO-Pin am Controller einspart. Der Nachteil ist, dass man dann das Busy-Flag nicht lesen kann, weswegen man nach jedem Befehl vorsichtshalber ein paar Mikrosekunden warten sollte, um dem LCD Zeit zum Ausführen des Befehls zu geben. Dummerweise schwankt die Ausführungszeit von Display zu Display und ist auch von der Betriebsspannung abhängig. Für professionellere Sachen also lieber den IO-Pin opfern und Busy abfragen.
* Der '''E''' Anschluss schließlich signalisiert dem LCD, dass die übrigen Datenleitungen jetzt korrekte Pegel angenommen haben und es die gewünschten Daten von den Datenleitungen bzw. Kommandos von den Datenleitungen übernehmen kann.

== Anschluss an den Controller ==

Jetzt da wir wissen, welche Anschlüsse das LCDs benötigt, können wir das LCD mit dem Mikrocontroller verbinden:

ACHTUNG: Es gibt Displays mit abweichender Anschluss-Belegung, falscher Anschluss kann zur Zerstörung führen! Daher immer das zugehörige Datenblatt zu Rate ziehen.

Einzelheiten unter [http://www.mikrocontroller.net/articles/HD44780 Artikel zum Controller HD44780]

{| class="wikitable"
!Pin #-LCD || Bezeichnung-LCD || Pin-µC
|-
!1
| Vss || GND
|-
!2
| Vcc || 5V
|-
!3
| Vee || GND oder Poti (siehe oben)
|-
!4
| RS || PD4 am AVR
|-
!5
| RW || GND
|-
!6
| E || PD5 am AVR
|-
!7
| DB0 ||rowspan="4"| offen (unbenutzt)
|-
!8
| DB1
|-
!9
| DB2
|-
!10
| DB3
|-
!11
| DB4 || PD0 am AVR
|-
!12
| DB5 || PD1 am AVR
|-
!13
| DB6 || PD2 am AVR
|-
!14
| DB7 || PD3 am AVR
|}

Wenn man die Steuerleitungen EN und RS auf Pins an einem anderen Port legen möchte, kann man so wie in diesem [http://www.mikrocontroller.net/topic/88543#751982 Forumsbeitrag] oder wie im Artikel [[Erweiterte LCD-Ansteuerung]] vorgehen.

Ok, alles ist verbunden, wenn man jetzt den Strom einschaltet sollten ein oder zwei schwarze Balken auf dem Display angezeigt werden. Erscheint trotz korrektem Anschluss nichts auf dem Display, so kann das auch am Kontrast des LCDs liegen. Die Balken werden dann zwar theoretisch angezeigt, sind aber nicht sichtbar, weil die Kontrastspannung zu hoch ist. Abhilfe schafft es hier, wenn man die Spannung am Schleifer des Potis nachmisst und in Richtung 0V verstellt. Zwischen 1V und 0V treten die Balken dann meist hervor.
Doch wie bekommt man jetzt die Befehle und Daten in das Display?

== Programmierung ==

=== Die LCD Routinen ===

Der folgende Satz von Ansteuerroutinen für ein Text-LCD ist in der Datei '''lcd-routines.c''' zusammengefasst. Diese Datei muss man beim Einrichten zusätzlich zum eigenen Hauptprogramm in sein Projekt aufnehmen. Dies geschieht beim AVR Studio unter Source Files im Fenster AVR GCC oder bei WinAVR im Makefile (z. B. durch SRC += lcd-routines.c).

Wichtig ist außerdem, dass die Optimierung bei der Compilierung eingeschaltet ist, sonst stimmen die Zeiten der Funktionen _delay_us() und _delay_ms() nicht und der Code wird wesentlich länger (Siehe Dokumentation der libc im WinAVR).

Als weitere Datei ist die Includedatei '''lcd-routines.h''' notwendig, die im Hauptprogramm und in '''lcd-routines.c''' eingebunden wird. Die Anpassung der Pinbelegung etc. macht man in dieser Datei.

==== Datei '''lcd-routines.h''' ====
<syntaxhighlight lang="c">
// Ansteuerung eines HD44780 kompatiblen LCD im 4-Bit-Interfacemodus
// http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung
//

#ifndef LCD_ROUTINES_H
#define LCD_ROUTINES_H

////////////////////////////////////////////////////////////////////////////////
// Hier die verwendete Taktfrequenz in Hz eintragen, wichtig!

#ifndef F_CPU
#define F_CPU 3686400
#endif

////////////////////////////////////////////////////////////////////////////////
// Pinbelegung für das LCD, an verwendete Pins anpassen
// Alle LCD Pins müssen an einem Port angeschlossen sein und die 4
// Datenleitungen müssen auf aufeinanderfolgenden Pins liegen

// LCD DB4-DB7 <--> PORTD Bit PD0-PD3
#define LCD_PORT PORTD
#define LCD_DDR DDRD
#define LCD_DB PD0

// LCD RS <--> PORTD Bit PD4 (RS: 1=Data, 0=Command)
#define LCD_RS PD4

// LCD EN <--> PORTD Bit PD5 (EN: 1-Impuls für Daten)
#define LCD_EN PD5

////////////////////////////////////////////////////////////////////////////////
// LCD Ausführungszeiten (MS=Millisekunden, US=Mikrosekunden)

#define LCD_BOOTUP_MS 15
#define LCD_ENABLE_US 20
#define LCD_WRITEDATA_US 46
#define LCD_COMMAND_US 42

#define LCD_SOFT_RESET_MS1 5
#define LCD_SOFT_RESET_MS2 1
#define LCD_SOFT_RESET_MS3 1
#define LCD_SET_4BITMODE_MS 5

#define LCD_CLEAR_DISPLAY_MS 2
#define LCD_CURSOR_HOME_MS 2

////////////////////////////////////////////////////////////////////////////////
// Zeilendefinitionen des verwendeten LCD
// Die Einträge hier sollten für ein LCD mit einer Zeilenlänge von 16 Zeichen passen
// Bei anderen Zeilenlängen müssen diese Einträge angepasst werden

#define LCD_DDADR_LINE1 0x00
#define LCD_DDADR_LINE2 0x40
#define LCD_DDADR_LINE3 0x10
#define LCD_DDADR_LINE4 0x50

////////////////////////////////////////////////////////////////////////////////
// Initialisierung: muss ganz am Anfang des Programms aufgerufen werden.
void lcd_init( void );

////////////////////////////////////////////////////////////////////////////////
// LCD löschen
void lcd_clear( void );

////////////////////////////////////////////////////////////////////////////////
// Cursor in die 1. Zeile, 0-te Spalte
void lcd_home( void );

////////////////////////////////////////////////////////////////////////////////
// Cursor an eine beliebige Position
void lcd_setcursor( uint8_t spalte, uint8_t zeile );

////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines einzelnen Zeichens an der aktuellen Cursorposition
void lcd_data( uint8_t data );

////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines Strings an der aktuellen Cursorposition
void lcd_string( const char *data );

////////////////////////////////////////////////////////////////////////////////
// Definition eines benutzerdefinierten Sonderzeichens.
// data muss auf ein Array[8] mit den Zeilencodes des zu definierenden Zeichens
// zeigen
void lcd_generatechar( uint8_t code, const uint8_t *data );

////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines Kommandos an das LCD.
void lcd_command( uint8_t data );

////////////////////////////////////////////////////////////////////////////////
// LCD Befehle und Argumente.
// Zur Verwendung in lcd_command

// Clear Display -------------- 0b00000001
#define LCD_CLEAR_DISPLAY 0x01

// Cursor Home ---------------- 0b0000001x
#define LCD_CURSOR_HOME 0x02

// Set Entry Mode ------------- 0b000001xx
#define LCD_SET_ENTRY 0x04

#define LCD_ENTRY_DECREASE 0x00
#define LCD_ENTRY_INCREASE 0x02
#define LCD_ENTRY_NOSHIFT 0x00
#define LCD_ENTRY_SHIFT 0x01

// Set Display ---------------- 0b00001xxx
#define LCD_SET_DISPLAY 0x08

#define LCD_DISPLAY_OFF 0x00
#define LCD_DISPLAY_ON 0x04
#define LCD_CURSOR_OFF 0x00
#define LCD_CURSOR_ON 0x02
#define LCD_BLINKING_OFF 0x00
#define LCD_BLINKING_ON 0x01

// Set Shift ------------------ 0b0001xxxx
#define LCD_SET_SHIFT 0x10

#define LCD_CURSOR_MOVE 0x00
#define LCD_DISPLAY_SHIFT 0x08
#define LCD_SHIFT_LEFT 0x00
#define LCD_SHIFT_RIGHT 0x04

// Set Function --------------- 0b001xxxxx
#define LCD_SET_FUNCTION 0x20

#define LCD_FUNCTION_4BIT 0x00
#define LCD_FUNCTION_8BIT 0x10
#define LCD_FUNCTION_1LINE 0x00
#define LCD_FUNCTION_2LINE 0x08
#define LCD_FUNCTION_5X7 0x00
#define LCD_FUNCTION_5X10 0x04

#define LCD_SOFT_RESET 0x30

// Set CG RAM Address --------- 0b01xxxxxx (Character Generator RAM)
#define LCD_SET_CGADR 0x40

#define LCD_GC_CHAR0 0
#define LCD_GC_CHAR1 1
#define LCD_GC_CHAR2 2
#define LCD_GC_CHAR3 3
#define LCD_GC_CHAR4 4
#define LCD_GC_CHAR5 5
#define LCD_GC_CHAR6 6
#define LCD_GC_CHAR7 7

// Set DD RAM Address --------- 0b1xxxxxxx (Display Data RAM)
#define LCD_SET_DDADR 0x80

#endif
</syntaxhighlight>

==== Datei '''lcd-routines.c''': ====
<syntaxhighlight lang="c">
// Ansteuerung eines HD44780 kompatiblen LCD im 4-Bit-Interfacemodus
// http://www.mikrocontroller.net/articles/HD44780
// http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung
//
// Die Pinbelegung ist über defines in lcd-routines.h einstellbar

#include <avr/io.h>
#include "lcd-routines.h"
#include <util/delay.h>

////////////////////////////////////////////////////////////////////////////////
// Erzeugt einen Enable-Puls
static void lcd_enable( void )
{
LCD_PORT |= (1<<LCD_EN); // Enable auf 1 setzen
_delay_us( LCD_ENABLE_US ); // kurze Pause
LCD_PORT &= ~(1<<LCD_EN); // Enable auf 0 setzen
}

////////////////////////////////////////////////////////////////////////////////
// Sendet eine 4-bit Ausgabeoperation an das LCD
static void lcd_out( uint8_t data )
{
data &= 0xF0; // obere 4 Bit maskieren

LCD_PORT &= ~(0xF0>>(4-LCD_DB)); // Maske löschen
LCD_PORT |= (data>>(4-LCD_DB)); // Bits setzen
lcd_enable();
}

////////////////////////////////////////////////////////////////////////////////
// Initialisierung: muss ganz am Anfang des Programms aufgerufen werden.
void lcd_init( void )
{
// verwendete Pins auf Ausgang schalten
uint8_t pins = (0x0F << LCD_DB) | // 4 Datenleitungen
(1<<LCD_RS) | // R/S Leitung
(1<<LCD_EN); // Enable Leitung
LCD_DDR |= pins;

// initial alle Ausgänge auf Null
LCD_PORT &= ~pins;

// warten auf die Bereitschaft des LCD
_delay_ms( LCD_BOOTUP_MS );

// Soft-Reset muss 3mal hintereinander gesendet werden zur Initialisierung
lcd_out( LCD_SOFT_RESET );
_delay_ms( LCD_SOFT_RESET_MS1 );

lcd_enable();
_delay_ms( LCD_SOFT_RESET_MS2 );

lcd_enable();
_delay_ms( LCD_SOFT_RESET_MS3 );

// 4-bit Modus aktivieren
lcd_out( LCD_SET_FUNCTION |
LCD_FUNCTION_4BIT );
_delay_ms( LCD_SET_4BITMODE_MS );

// 4-bit Modus / 2 Zeilen / 5x7
lcd_command( LCD_SET_FUNCTION |
LCD_FUNCTION_4BIT |
LCD_FUNCTION_2LINE |
LCD_FUNCTION_5X7 );

// Display ein / Cursor aus / Blinken aus
lcd_command( LCD_SET_DISPLAY |
LCD_DISPLAY_ON |
LCD_CURSOR_OFF |
LCD_BLINKING_OFF);

// Cursor inkrement / kein Scrollen
lcd_command( LCD_SET_ENTRY |
LCD_ENTRY_INCREASE |
LCD_ENTRY_NOSHIFT );

lcd_clear();
}

////////////////////////////////////////////////////////////////////////////////
// Sendet ein Datenbyte an das LCD
void lcd_data( uint8_t data )
{
LCD_PORT |= (1<<LCD_RS); // RS auf 1 setzen

lcd_out( data ); // zuerst die oberen,
lcd_out( data<<4 ); // dann die unteren 4 Bit senden

_delay_us( LCD_WRITEDATA_US );
}

////////////////////////////////////////////////////////////////////////////////
// Sendet einen Befehl an das LCD
void lcd_command( uint8_t data )
{
LCD_PORT &= ~(1<<LCD_RS); // RS auf 0 setzen

lcd_out( data ); // zuerst die oberen,
lcd_out( data<<4 ); // dann die unteren 4 Bit senden

_delay_us( LCD_COMMAND_US );
}

////////////////////////////////////////////////////////////////////////////////
// Sendet den Befehl zur Löschung des Displays
void lcd_clear( void )
{
lcd_command( LCD_CLEAR_DISPLAY );
_delay_ms( LCD_CLEAR_DISPLAY_MS );
}

////////////////////////////////////////////////////////////////////////////////
// Sendet den Befehl: Cursor Home
void lcd_home( void )
{
lcd_command( LCD_CURSOR_HOME );
_delay_ms( LCD_CURSOR_HOME_MS );
}

////////////////////////////////////////////////////////////////////////////////
// Setzt den Cursor in Spalte x (0..15) Zeile y (1..4)

void lcd_setcursor( uint8_t x, uint8_t y )
{
uint8_t data;

switch (y)
{
case 1: // 1. Zeile
data = LCD_SET_DDADR + LCD_DDADR_LINE1 + x;
break;

case 2: // 2. Zeile
data = LCD_SET_DDADR + LCD_DDADR_LINE2 + x;
break;

case 3: // 3. Zeile
data = LCD_SET_DDADR + LCD_DDADR_LINE3 + x;
break;

case 4: // 4. Zeile
data = LCD_SET_DDADR + LCD_DDADR_LINE4 + x;
break;

default:
return; // für den Fall einer falschen Zeile
}

lcd_command( data );
}

////////////////////////////////////////////////////////////////////////////////
// Schreibt einen String auf das LCD

void lcd_string( const char *data )
{
while( *data != '\0' )
lcd_data( *data++ );
}

////////////////////////////////////////////////////////////////////////////////
// Schreibt ein Zeichen in den Character Generator RAM

void lcd_generatechar( uint8_t code, const uint8_t *data )
{
// Startposition des Zeichens einstellen
lcd_command( LCD_SET_CGADR | (code<<3) );

// Bitmuster übertragen
for ( uint8_t i=0; i<8; i++ )
{
lcd_data( data[i] );
}
}
</syntaxhighlight>

=== LCD Beispiel 1 ===
Ein Hauptprogramm, welches die LCD Funktionen benutzt, sieht zb. so aus:

<syntaxhighlight lang="c">
//
// Anpassungen im makefile:
// ATMega8 => MCU=atmega8 im makefile einstellen
// lcd-routines.c in SRC = ... Zeile anhängen
//
#include <avr/io.h>
#include "lcd-routines.h"

int main(void)
{
// Initialisierung des LCD
// Nach der Initialisierung müssen auf dem LCD vorhandene schwarze Balken
// verschwunden sein
lcd_init();

// Text in einzelnen Zeichen ausgeben
lcd_data( 'T' );
lcd_data( 'e' );
lcd_data( 's' );
lcd_data( 't' );

// Die Ausgabemarke in die 2te Zeile setzen
lcd_setcursor( 0, 2 );

// erneut Text ausgeben, aber diesmal komfortabler als String
lcd_string("Hello World!");

while(1)
{
}

return 0;
}
</syntaxhighlight>

=== LCD Beispiel 2 ===
Ein Hauptprogramm, welches eine Variable ausgibt, sieht zb. so aus.
Mittels der itoa() Funktion (itoa = Integer To Ascii ) wird von einem Zahlenwert eine textuelle Repräsentierung ermittelt (sprich: ein String erzeugt) und dieser String mit der bereits vorhandenen Funktion lcd_string ausgegeben. Das Einrichten des Projekts ist wie in Beispiel 1.

<syntaxhighlight lang="c">
//
// Anpassungen im makefile:
// ATMega8 => MCU=atmega8 im makefile einstellen
// lcd-routines.c in SRC = ... Zeile anhängen
//
#include <avr/io.h>
#include <stdlib.h>
#include "lcd-routines.h"

// Beispiel
int variable = 42;

int main(void)
{
lcd_init();

// Ausgabe des Zeichens dessen ASCII-Code gleich dem Variablenwert ist
// (Im Beispiel entspricht der ASCII-Code 42 dem Zeichen *)
// http://www.code-knacker.de/ascii.htm
lcd_data( variable );

lcd_setcursor( 0, 2 );

// Ausgabe der Variable als Text in dezimaler Schreibweise
{
// ... umwandeln siehe FAQ Artikel bei http://www.mikrocontroller.net/articles/FAQ
// WinAVR hat eine itoa()-Funktion, das erfordert obiges #include <stdlib.h>
char Buffer[20]; // in diesem {} lokal
itoa( variable, Buffer, 10 );

// ... ausgeben
lcd_string( Buffer );
}

while(1)
{
}

return 0;
}
</syntaxhighlight>

== Siehe auch ==

* [[Erweiterte LCD-Ansteuerung]]
* [[Pseudo-Graphische LCD-Ansteuerung]]
* [http://www.mikrocontroller.net/topic/316826#3431235 Ermittlung der Startadresse der einzelnen Zeilen]

== Weblinks ==

* [http://homepage.hispeed.ch/peterfleury/avr-software.html#libs Lib zur HD44780 Ansteuerung (AVR)]
* [http://www.nongnu.org/avr-libc/user-manual/group__stdiodemo.html Using the standard IO facilities] - Demoprojekt zur Text-LCD Ansteuerung (HD44780 komp.) in der avr-libc

[[Kategorie:Avr-gcc Tutorial]]
[[Kategorie:LCD]]

Erweiterte LCD-Ansteuerung

2013-12-04T13:50:44Z

145.225.60.4:

== Einleitung ==

Die folgende Software beruht zum größten Teil auf dem [[AVR-GCC-Tutorial/LCD-Ansteuerung|Tutorial zur LCD-Ansteuerung]]. Eine Anpassung war jedoch nötig, weil in der Tutorial-Vorlage die vier LCD-Datenleitungen DB4 bis DB7 immer mit den unteren vier Portleitungen PIN0 bis PIN3 des Ausgabeports verbunden sein müssen. Die hier vorgestellte Lösung ermöglicht es, die als Datenleitung verwendeten Pins innerhalb des Ausgabeports freier zu konfigurieren. D.h.

* Die vier Datenleitungen können als Bus beliebig an einem Port gelegt werden
* Allerdings muss die Reihenfolge immer noch eingehalten werden, sprich, DB4-DB7 in aufsteigender Reihenfolge!
* Die beiden anderen Steuersignale ''E'' und ''RS'' sind auf den übrigen vier Pins eines Ports frei wählbar
* Das Signal ''RW'' muss am LCD fest auf GND gelegt sein, es werden nur Schreibzugriffe ausgeführt
* Das Busy-Flag wird '''nicht''' genutzt
* Wer die ultimativ freie Zuordnung von Pins über Portgrenzen hinweg haben will, muss die bekannte Bibliothek von Peter Fleury nutzen, siehe Links am Ende des Artikels

Ansonsten sind einige [[Strukturierte Programmierung auf Mikrocontrollern|kosmetische Änderungen]] gemacht worden, die den Code etwas leichter lesbar machen sollen. So sind sämtliche Kommandos und Kommandooptionen als #defines ausgeführt. Gegenüber dem Original sind folgende Änderungen bzw. Erweiterungen gemacht worden:

* konfigurierbare Datenleitungen, z.B. zum Anschluss von DB4-DB7 an PD4-PD7
* Funktionsname lcd_setcursor() statt set_cursor() (einheitliche Namenskonvention)
* einheitliche Verwendung von uint8_t
* neue Funktion lcd_out() für eine 4bit-Operation
* alle Kommandos und Kommandooptionen des LCD als #defines ausgeführt
* neue Funktion lcd_generatechar() und lcd_generatechar_P() zum [[Pseudo-Graphische_LCD-Ansteuerung|Generieren eines Zeichens im Character Generator RAM]]
* ein Demoprogramm, in dem alle Funktionen der Bibliotek in ihrer Nutzung dargestellt sind

Alle Dateien sind als [[media:LCD_Tutorial.zip | ZIP-Archiv]] hier verfügbar. Das Programm wurde komplett auf einem ATmega8515 getestet. Es ist auf ein 4x16 LCD ausgelegt. Wenn man das Programm auf seiner eigenen Hardware testen will, müssen folgende Dinge angepasst werden

* in main.h das #define F_CPU für die Taktfrequenz
* in lcd.h die Port- und Pinzuordnung mit LCD_PORT, LCD_DDR etc.

Der Quelltext ist ausgiebig kommentiert und sollte die Funktionen gut erklären.

== Die erweiterten LCD-Routinen ==

Datei '''lcd.h'''
<syntaxhighlight lang="c">
// Ansteuerung eines HD44780 kompatiblen LCD im 4-Bit-Interfacemodus
// http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung
//

#ifndef LCD_ROUTINES_H
#define LCD_ROUTINES_H

#include <avr/pgmspace.h>

////////////////////////////////////////////////////////////////////////////////
// Pinbelegung für das LCD, an verwendete Pins anpassen
// alle Pins müssen in einem Port liegen
// die 4 Bit für die Daten müssen zusammenliegen, können aber an einer
// beliebigen Postion anfangen

#ifndef LCD_PORTS
#define LCD_PORTS

#define LCD_PORT PORTC
#define LCD_DDR DDRC

// 4 Bit LCD Datenbus DB4-DB7, das unterste Bit DB4 kann auf den Portbits 0..4 liegen

// LCD DB4-DB7 <--> PORTC Bit PC0-PC3
#define LCD_DB PC0

// LCD Steuersignale RS und EN

// LCD RS <--> PORTC Bit PC4 (RS: 0=Data, 1=Command)
#define LCD_RS PC4

// LCD EN <--> PORTC Bit PC5 (EN: 1-Impuls für Daten)
#define LCD_EN PC5

#endif // LCD_PORTS

////////////////////////////////////////////////////////////////////////////////
// LCD Ausführungszeiten (MS=Millisekunden, US=Mikrosekunden)

#ifndef LCD_TIMINGS
#define LCD_TIMINGS

#define LCD_BOOTUP_MS 15
#define LCD_ENABLE_US 1
#define LCD_WRITEDATA_US 46
#define LCD_COMMAND_US 42

#define LCD_SOFT_RESET_MS1 5
#define LCD_SOFT_RESET_MS2 1
#define LCD_SOFT_RESET_MS3 1
#define LCD_SET_4BITMODE_MS 5

#define LCD_CLEAR_DISPLAY_MS 2
#define LCD_CURSOR_HOME_MS 2

#endif // LCD_TIMINGS

////////////////////////////////////////////////////////////////////////////////
// Zeilendefinitionen des verwendeten LCD
// die Einträge hier sollten für ein LCD mit einer Zeilenlänge von 16 Zeichen passen
// bei anderen Zeilenlängen müssen diese Einträge angepasst werden

#define LCD_DDADR_LINE1 0x00
#define LCD_DDADR_LINE2 0x40
#define LCD_DDADR_LINE3 0x10
#define LCD_DDADR_LINE4 0x50

////////////////////////////////////////////////////////////////////////////////
// Initialisierung: muss ganz am Anfang des Programms aufgerufen werden.
void lcd_init( void );

////////////////////////////////////////////////////////////////////////////////
// LCD löschen
void lcd_clear( void );

////////////////////////////////////////////////////////////////////////////////
// Cursor in die erste Zeile, erste Spalte (Position 0,0)
void lcd_home( void );

////////////////////////////////////////////////////////////////////////////////
// Cursor an eine beliebige Position
void lcd_setcursor( uint8_t x, uint8_t y );

////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines einzelnen Zeichens an der aktuellen Cursorposition
void lcd_data( uint8_t data );

////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines Strings an der aktuellen Cursorposition
// String liegt im RAM
void lcd_string( const char *data );

////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines Strings an einer bestimmten Cursorposition
// String liegt im RAM
void lcd_string_xy( uint8_t x, uint8_t y, const char *data );

////////////////////////////////////////////////////////////////////////////////
// Ausgabe einer Zahl an der aktuellen Cursorposition
// Zahl liegt im RAM
void lcd_number( uint8_t number, uint8_t len, uint8_t fill );

////////////////////////////////////////////////////////////////////////////////
// Ausgabe einer Zahl an einer bestimmten Cursorposition
// Zahl liegt im RAM
void lcd_number_xy( uint8_t x, uint8_t y, uint8_t number, uint8_t len, uint8_t fill );

////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines Strings an der aktuellen Cursorposition
// String liegt im Flash
void lcd_string_P( PGM_P data );

////////////////////////////////////////////////////////////////////////////////
// Definition eines benutzerdefinierten Sonderzeichens.
// data muss auf ein Array mit den Zeilencodes des zu definierenden Zeichens
// zeigen, Daten liegen im RAM
void lcd_generatechar( uint8_t code, const uint8_t *data, uint8_t lines );

////////////////////////////////////////////////////////////////////////////////
// Definition eines benutzerdefinierten Sonderzeichens.
// data muss auf ein Array mit den Zeilencodes des zu definierenden Zeichens
// zeigen, Daten liegen im FLASH
void lcd_generatechar_P( uint8_t code, PGM_P data, uint8_t lines );

////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines Kommandos an das LCD.
void lcd_command( uint8_t data );

////////////////////////////////////////////////////////////////////////////////
// LCD Befehle und Argumente.
// zur Verwendung in lcd_command

// Clear Display -------------- 0b00000001
#define LCD_CLEAR_DISPLAY 0x01

// Cursor Home ---------------- 0b0000001x
#define LCD_CURSOR_HOME 0x02

// Set Entry Mode ------------- 0b000001xx
#define LCD_SET_ENTRY 0x04

#define LCD_ENTRY_DECREASE 0x00
#define LCD_ENTRY_INCREASE 0x02
#define LCD_ENTRY_NOSHIFT 0x00
#define LCD_ENTRY_SHIFT 0x01

// Set Display ---------------- 0b00001xxx
#define LCD_SET_DISPLAY 0x08

#define LCD_DISPLAY_OFF 0x00
#define LCD_DISPLAY_ON 0x04
#define LCD_CURSOR_OFF 0x00
#define LCD_CURSOR_ON 0x02
#define LCD_BLINKING_OFF 0x00
#define LCD_BLINKING_ON 0x01

// Set Shift ------------------ 0b0001xxxx
#define LCD_SET_SHIFT 0x10

#define LCD_CURSOR_MOVE 0x00
#define LCD_DISPLAY_SHIFT 0x08
#define LCD_SHIFT_LEFT 0x00
#define LCD_SHIFT_RIGHT 0x01

// Set Function --------------- 0b001xxxxx
#define LCD_SET_FUNCTION 0x20

#define LCD_FUNCTION_4BIT 0x00
#define LCD_FUNCTION_8BIT 0x10
#define LCD_FUNCTION_1LINE 0x00
#define LCD_FUNCTION_2LINE 0x08
#define LCD_FUNCTION_5X7 0x00
#define LCD_FUNCTION_5X10 0x04

#define LCD_SOFT_RESET 0x30

// Set CG RAM Address --------- 0b01xxxxxx (Character Generator RAM)
#define LCD_SET_CGADR 0x40

#define LCD_GC_CHAR0 0
#define LCD_GC_CHAR1 1
#define LCD_GC_CHAR2 2
#define LCD_GC_CHAR3 3
#define LCD_GC_CHAR4 4
#define LCD_GC_CHAR5 5
#define LCD_GC_CHAR6 6
#define LCD_GC_CHAR7 7

// Set DD RAM Address --------- 0b1xxxxxxx (Display Data RAM)
#define LCD_SET_DDADR 0x80

#endif // LCD_ROUTINES_H
</syntaxhighlight>

Datei '''lcd.c'''
<syntaxhighlight lang="c">
// Ansteuerung eines HD44780 kompatiblen LCD im 4-Bit-Interfacemodus
// http://www.mikrocontroller.net/articles/HD44780
// http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung
//
// Die Pinbelegung ist über defines in lcd.h einstellbar

#include <avr/io.h>
#include "main.h"
#include "lcd.h"
#include <util/delay.h>

/////////////////////////////////////////////////////////////////////////////////
// Erzeugt einen Enable-Puls

static void lcd_enable( void ) {
LCD_PORT |= (1<<LCD_EN); // Enable auf 1 setzen
_delay_us( LCD_ENABLE_US ); // kurze Pause
LCD_PORT &= ~(1<<LCD_EN); // Enable auf 0 setzen
}

////////////////////////////////////////////////////////////////////////////////
// Sendet eine 4-bit Ausgabeoperation an das LCD
static void lcd_out( uint8_t data ) {
data &= 0xF0; // obere 4 Bit maskieren
LCD_PORT &= ~(0xF0>>(4-LCD_DB)); // Maske löschen
LCD_PORT |= (data>>(4-LCD_DB)); // Bits setzen
lcd_enable();
}

////////////////////////////////////////////////////////////////////////////////
// Initialisierung: muss ganz am Anfang des Programms aufgerufen werden.
void lcd_init( void ) {
// verwendete Pins auf Ausgang schalten
uint8_t pins = (0x0F << LCD_DB) | // 4 Datenleitungen
(1<<LCD_RS) | // R/S Leitung
(1<<LCD_EN); // Enable Leitung
LCD_DDR |= pins;

// initial alle Ausgänge auf Null
LCD_PORT &= ~pins;

// warten auf die Bereitschaft des LCD
_delay_ms( LCD_BOOTUP_MS );

// Soft-Reset muss 3mal hintereinander gesendet werden zur Initialisierung
lcd_out( LCD_SOFT_RESET );
_delay_ms( LCD_SOFT_RESET_MS1 );

lcd_enable();
_delay_ms( LCD_SOFT_RESET_MS2 );

lcd_enable();
_delay_ms( LCD_SOFT_RESET_MS3 );

// 4-bit Modus aktivieren
lcd_out( LCD_SET_FUNCTION |
LCD_FUNCTION_4BIT );
_delay_ms( LCD_SET_4BITMODE_MS );

// 4-bit Modus / 2 Zeilen / 5x7
lcd_command( LCD_SET_FUNCTION |
LCD_FUNCTION_4BIT |
LCD_FUNCTION_2LINE |
LCD_FUNCTION_5X7 );

// Display ein / Cursor aus / Blinken aus
lcd_command(LCD_SET_DISPLAY |
LCD_DISPLAY_ON |
LCD_CURSOR_OFF |
LCD_BLINKING_OFF);

// Cursor inkrement / kein Scrollen
lcd_command( LCD_SET_ENTRY |
LCD_ENTRY_INCREASE |
LCD_ENTRY_NOSHIFT );

lcd_clear();
}

////////////////////////////////////////////////////////////////////////////////
// Sendet ein Datenbyte an das LCD
void lcd_data( uint8_t data ) {
LCD_PORT |= (1<<LCD_RS); // RS auf 1 setzen

lcd_out( data ); // zuerst die oberen,
lcd_out( data<<4 ); // dann die unteren 4 Bit senden

_delay_us( LCD_WRITEDATA_US );
}

////////////////////////////////////////////////////////////////////////////////
// Sendet einen Befehl an das LCD
void lcd_command( uint8_t data ) {
LCD_PORT &= ~(1<<LCD_RS); // RS auf 0 setzen

lcd_out( data ); // zuerst die oberen,
lcd_out( data<<4); // dann die unteren 4 Bit senden

_delay_us(LCD_COMMAND_US );
}

////////////////////////////////////////////////////////////////////////////////
// Sendet den Befehl zur Löschung des Displays
void lcd_clear( void ) {
lcd_command( LCD_CLEAR_DISPLAY );
_delay_ms( LCD_CLEAR_DISPLAY_MS );
}

////////////////////////////////////////////////////////////////////////////////
// Sendet den Befehl: Cursor Home
void lcd_home( void ) {
lcd_command( LCD_CURSOR_HOME );
_delay_ms( LCD_CURSOR_HOME_MS );
}

////////////////////////////////////////////////////////////////////////////////
// Setzt den Cursor in Zeile y (0..3) Spalte x (0..15)

void lcd_setcursor( uint8_t x, uint8_t y ) {
uint8_t data;

switch (y) {
case 0: // 1. Zeile
data = LCD_SET_DDADR + LCD_DDADR_LINE1 + x;
break;
case 1: // 2. Zeile
data = LCD_SET_DDADR + LCD_DDADR_LINE2 + x;
break;
case 2: // 3. Zeile
data = LCD_SET_DDADR + LCD_DDADR_LINE3 + x;
break;
case 3: // 4. Zeile
data = LCD_SET_DDADR + LCD_DDADR_LINE4 + x;
break;
default:
return; // für den Fall einer falschen Zeile
}

lcd_command( data );
}

////////////////////////////////////////////////////////////////////////////////
// Schreibt einen String auf das LCD

void lcd_string( const char *data ) {
while( *data != '\0' )
lcd_data( *data++ );
}

void lcd_string_xy( uint8_t x, uint8_t y, const char *data ) {
lcd_setcursor( x, y );
lcd_string( data );
}

////////////////////////////////////////////////////////////////////////////////
// Schreibt eine Zahl auf das LCD

void lcd_number( uint8_t number, uint8_t len, uint8_t fill ) {
uint8_t digit1 = 0;
uint8_t digit2 = 0;
while (number >= 100) {
digit1++;
number -= 100;
}
while (number >= 10) {
digit2++;
number -= 10;
}
if (len > 2) lcd_data( (digit1 != 0) ? digit1+'0' : fill );
if (len > 1) lcd_data( ((digit1 != 0) || (digit2 != 0)) ? digit2+'0' : fill );
lcd_data( number+'0' );
}

void lcd_number_xy( uint8_t x, uint8_t y, uint8_t number, uint8_t len, uint8_t fill ) {
lcd_setcursor( x, y );
lcd_number( number, len, fill );
}

////////////////////////////////////////////////////////////////////////////////
// Schreibt einen String auf das LCD
// String liegt direkt im Flash Speicher

void lcd_string_P( PGM_P data ) {
uint8_t tmp;

tmp = pgm_read_byte( data );
while( tmp != '\0' ) {
lcd_data( tmp );
data++;
tmp = pgm_read_byte( data );
}
}

////////////////////////////////////////////////////////////////////////////////
// Schreibt ein Zeichen in den Character Generator RAM
// Daten liegen direkt im RAM

void lcd_generatechar( uint8_t code, const uint8_t *data, uint8_t lines ) {
uint8_t i;

// Startposition des Zeichens einstellen
lcd_command( LCD_SET_CGADR | (code<<3) );
// Bitmuster übertragen
for ( i=0; i<lines; i++ ) {
lcd_data( *data++ );
}
}

////////////////////////////////////////////////////////////////////////////////
// Schreibt ein Zeichen in den Character Generator RAM
// Daten liegen direkt im Flash-Speicher

void lcd_generatechar_P( uint8_t code, PGM_P data, uint8_t lines ) {
uint8_t i;

// Startposition des Zeichens einstellen
lcd_command( LCD_SET_CGADR | (code<<3) );
// Bitmuster übertragen
for ( i=0; i<lines; i++ ) {
lcd_data( pgm_read_byte(data) );
data++;
}
}
</syntaxhighlight>

== Weblinks ==

* [http://homepage.hispeed.ch/peterfleury/avr-software.html#libs Sehr flexible Bibliothek zur HD44780 Ansteuerung (AVR)] (P. Fleury)
* [http://www.mikrocontroller.net/topic/316826#3431235 Ermittlung der Startadresse der einzelnen Zeilen]

[[Kategorie:LCD]]

HD44780

2013-12-04T13:50:21Z

145.225.60.4:

Der HD44780 ist ein Steuer-IC für Textdisplays (siehe [[LCD]]). Praktisch alle Textdisplays werden mit diesem oder einem kompatiblen Controller (z. B. KS0066) angesteuert.

== Allgemeine Ansteuerung ==

=== Pinbelegung ===

Die Pinbelegung des ICs selber ist für den Anwender praktisch uninteressant. Hier ist die häufigste Anschluss-Belegung der damit ausgestatteten LCD-Module angegeben.

ACHTUNG: Es gibt Displays mit abweichender Anschluss-Belegung, falscher Anschluss kann zur Zerstörung führen! Daher immer das zugehörige Datenblatt zu Rate ziehen.

{| class="wikitable"
!Pin || Funktion || Beschreibung
|-
|1 || | Vee || Versorgungsspannung GND (es gibt auch Displays mit Vcc an Pin 1)
|-
|2 || | Vcc || Versorgungsspannung, meistens 5V (es gibt auch Displays mit Vee an Pin 2 oder an Pin 14, im letzten Fall rutschen die Bezeichnungen dann entsprechend nach unten)
|-
|3 || | V0 ||Kontrastspannung, zwischen VEE und VCC, kann auf VSS gelegt oder via Poti angeschlossen werden. Bei großflächigen LCDs oder LCDs für den erweiterten Temperaturbereich kann auch eine negative Kontrastspannung nötig sein.
|-
|4 || | RS || Registerauswahl 0 = Befehlsregister, 1 = Datenregister
|-
|5 || | R/W || Lese- oder Schreibzugriff; kann fest auf GND gelegt werden, wenn Busy-Auswertung durch Timing ersetzt wird 0 = Schreiben, 1 = Lesen
|-
|6 || | E || Taktleitung (Achtung! Diese Leitung hat im Gegensatz zu den anderen bei einigen Displays keinen internen Pullup, man muss also einen externen vorsehen, falls man mit Open-Drain-Ausgängen arbeitet.)
|-
|7 || | DB0 || Datenleitung (bleibt im 4-Bit-Modus offen)
|-
|8 || |DB1 || Datenleitung (bleibt im 4-Bit-Modus offen)
|-
|9 || |DB2 || Datenleitung (bleibt im 4-Bit-Modus offen)
|-
|10 || |DB3 || Datenleitung (bleibt im 4-Bit-Modus offen)
|-
|11 || |DB4 || Datenleitung
|-
|12 || |DB5 || Datenleitung
|-
|13 || |DB6 || Datenleitung
|-
|14 || |DB7 || Datenleitung
|-
|15 || A || Anode der LED-Hintergrundbeleuchtung (fakultativ)
|-
|16 || K || Kathode der LED-Hintergrundbeleuchtung (fakultativ)
|-
| || || Es gibt auch Displays ohne die Datenleitungen DB0-3 (werden nur im 4-Bit-Modus angesteuert), dann rutschen die Bezeichnungen dann entsprechend nach unten
|}

===Speicher===

Ein HD44780 besitzt mehrere Speicher. In ihnen wird der Inhalt des Displays sowie das Aussehen von Sonderzeichen gespeichert.

==== CGROM ====

Der '''C'''haracter '''G'''enerator '''ROM''' enthält die Zeichen in Form von 5x8 oder 5x10 Punktmatrizen. Er kann nicht geändert werden, ausser man sendet einen EEPROM zu Hitachi für eine Massenproduktion. Es sind viele verschiedene ROMs (Zeichensätze, engl. Fonts) verfügbar. Er ist für den Anwender nicht zugänglich.

==== CGRAM ====

Im '''C'''haracter '''G'''enerator '''RAM''' können acht 5x8 Pixel oder vier 5x10 Pixel große benutzerdefinierte Zeichen abgelegt werden. Braucht man keine benutzerdefinierten Zeichen, kann man diesen Bereich als Auslagerungsspeicher für den ansteuernden Mikrocontroller benutzen. Dazu muss aber die '''R/W''' Leitung angesteuert werden.

==== DDRAM ====

Im '''D'''isplay '''D'''ata '''RAM''' ist der Inhalt des LCDs gespeichert. Die Kodierung orientiert sich weitestgehend am ASCII Zeichensatz.

Das DDRAM hat üblicherweise mehr Speicherstellen als das Display gleichzeitig anzeigt. Durch Anwenden der Display-Shift-Befehle können die nicht sichtbaren Zeichen zur Anzeige gebracht werden.

Benachbarte Zeichen haben im DDRAM nicht zwangsweise auch aufeinanderfolgende Adressen. So ist etwa bei 1x16-Displays (1 Zeile, 16 Zeichen) oft in der Mitte des Displays ein Adresssprung von 0x07 auf 0x40; bei 2x16-Displays ist der Sprung auf 0x40 normalerweise (programmiererfreundlich) zwischen Ende der ersten und Beginn der zweiten Zeile. Näheres ist dem Datenblatt zu entnehmen.

=== Kommandos ===

{| class="wikitable"
|+ '''HD44780 Befehlssatz'''
!Befehl
!RS
!RW
!D7
!D6
!D5
!D4
!D3
!D2
!D1
!D0
|-
|Bildschirminhalt löschen
|0
|0
|0
|0
|0
|0
|0
|0
|0
|1
|-
|Cursor auf Startpos
|0
|0
|0
|0
|0
|0
|0
|0
|1
|X
|-
|Modus festlegen
|0
|0
|0
|0
|0
|0
|0
|1
|I/D
|S
|-
|Display/Cursor
|0
|0
|0
|0
|0
|0
|1
|D
|C
|B
|-
|Cursor/Display schieben
|0
|0
|0
|0
|0
|1
|S/C
|R/L
|X
|X
|-
|Funktionen
|0
|0
|0
|0
|1
|DL
|N
|F
|X
|X
|-
|CGRAM Adresse setzen
|0
|0
|0
|1
|colspan ="6" align="center"|CGRAM-Adresse
|-
|DDRAM Adresse setzen
|0
|0
|1
|colspan="7" align="center"|DDRAM-Adresse
|-
|Adresse/Status lesen
|0
|1
|BF
|colspan="7" align="center"|CG-/DDRAM-Adresse
|-
|Daten in DDRAM/CGRAM schreiben
|1
|0
|colspan="8" align="center"|Daten
|-
|Daten aus DDRAM/CGRAM lesen
|1
|1
|colspan="8" align="center"|Daten
|}

{| class="wikitable"
|+ '''Kodierung der Steuerbits'''
!Bit
!0
!1
|-
|I/D
|Cursorposition dekrementieren
|Cursorposition inkrementieren
|-
|S
|Displayinhalt fest
|Displayinhalt weiterschieben
|-
|D
|Display aus
|Display an
|-
|C
|Cursor aus
|Cursor an
|-
|B
|Cursor blinkt nicht
|Cursor blinkt
|-
|S/C
|Cursor bewegen
|Displayinhalt schieben
|-
|R/L
|Nach links schieben
|Nach rechts schieben
|-
|DL
|4-Bit Interface
|8-Bit Interface
|-
|N
|1-zeiliges Display
|2/4-zeiliges Display
|-
|F
|5×7-Font
|5×10-Font
|-
|BF
|Kann Kommandos annehmen
|Ist beschäftigt
|}

== Ansteuerung per Microcontroller ==

Die Ansteuerung eines HD44780-basierten Displays gestaltet sich sowohl in Bezug auf den Hardware- als auch den Softwareaufwand recht einfach. Sie eignet sich somit sehr gut als Übungsprojekt für Anfänger.

Das HD44780-Interface besteht aus acht Datenleitungen (D0-D7) sowie den drei Steuerleitungen RS ('''R'''egister '''S'''elect), R/W ('''R'''ead/'''W'''rite) und E ('''E'''nable). Die Displays werden mit 5V Betriebsspannung versorgt, die Kontrastspannung V0 bekommt man, indem man ein 10kΩ-[[Potentiometer]] zwischen VCC und GND anschließt und den mittleren Anschluss als Kontrastspannung verwendet. Bei ca. 0,5 Volt werden dann die Pixel sichtbar. Optional haben viele Displays noch eine LED-Beleuchtung eingebaut, diese kann manchmal direkt an 5V angeschlossen werden, da der Vorwiderstand auf der LCD-Platine integriert ist. Oft ist aber auch ein externer Vorwiderstand nötig! Darum vorher besser im Datenblatt nachschauen.

Möchte man IO-Pins am Mikrocontroller sparen, kann das Display im 4-Bit-Modus betrieben werden, die Dateneingänge D0 bis D3 bleiben dann offen. Durch zusätzliche Bauteile ([[AVR-Tutorial:_Schieberegister]]) kann die Zahl der benötigten Port-Pins noch weiter reduziert werden.

Beispielprogramme zur Ansteuerung findet man zuhauf im Internet, u.a. auch hier: [[AVR-Tutorial: LCD]] und [[AVR-GCC-Tutorial/LCD-Ansteuerung|AVR-GCC-Tutorial: LCD-Ansteuerung]]

=== Fertige Projekte oder Bibliotheken ===

* Peter Fleurys [http://homepage.hispeed.ch/peterfleury/avr-software.html LCD library for HD44870 based LCDs]
* Kai Klenovseks [http://kk.elektronik-4u.de/index.php?Sid=9 LCD library for HD44870 based LCDs]
* avr-libc [http://www.nongnu.org/avr-libc/user-manual/group__stdiodemo.html Demo-Projekt für stdio]
* [http://www.ipd.uka.de/~buchmann/microcontroller/lcd.htm Grundlagen und Code für 8051] von Erik Buchmann
* [http://www.ekenrooi.net/lcd/lcd.shtml ''How to control a HD44780-based Character-LCD''] von Peter Ouwehand. Beispiele für 8051, PIC16C54, AT90S2313
* Firma wickenhäuser [http://www.wickenhaeuser.de 8051 Compiler und Treiber für LCDs ]

=== Benutzerdefinierte Sonderzeichen ===
* Benutzerspezifische Zeichen für den HD44780 mit dem [http://www.mugui.de/bin/menu.php?link=hd44780_demo&lang=de Font and Bitmap Generator] erstellen
* [http://www.darreltaylor.com/files/CustChar.htm Custom Character Generator] by Darrel Taylor (online, JavaScript)
* http://www.parallax.com/ProductInfo/Microcontrollers/BASICStampSoftware/LCDCharacterCreator/tabid/482/Default.aspx

== Siehe auch ==

* [[AVR-GCC-Tutorial/LCD-Ansteuerung]]
* [[Erweiterte LCD-Ansteuerung]]
* [[Pseudo-Graphische LCD-Ansteuerung]]
* [http://www.mikrocontroller.net/topic/316826#3431235 Ermittlung der Startadresse der einzelnen Zeilen]

== Weblinks ==

* [http://www.sprut.de/electronic/lcd/ Ausführliche Beschreibung des HD44780]
* [http://homepage.hispeed.ch/peterfleury/avr-software.html#libs Lib zur HD44780 Ansteuerung (AVR)]
* [http://pic-projekte.de/wiki/index.php?title=Ansteuern_des_HD44780_mit_den_C18-Libraries Ansteuern des HD44780 mit den C18-Libraries - PIC]
* [http://www.fonts2u.com/hd44780-regular.font TTF Matrix Pixel Font]

[[Category:Bauteile]]
[[Category:Displays und Anzeigen]]
[[Category:LCD]]

AVR-GCC-Tutorial/LCD-Ansteuerung

2013-12-04T13:48:01Z

145.225.60.4:

==Das LCD und sein Controller==

Die meisten Text-LCDs verwenden den Controller [[HD44780]] oder einen kompatiblen (z. B. KS0070) und haben 14 oder 16 Pins. Hier ist die häufigste Anschluss-Belegung angegeben.

;Achtung: Es gibt Displays mit abweichender Anschluss-Belegung, z.B. TC1602E (Pollin 120420). Falscher Anschluss kann zur Zerstörung führen! Daher immer das zugehörige Datenblatt zu Rate ziehen. Einzelheiten unter Artikel zum Controller [[HD44780]].

{| class="wikitable"
! Pin # || Bezeichnung || Funktion
|-
! 1
| Vss || GND (beim TC1602E Vdd=Vcc)
|-
! 2
| Vdd/Vcc || 5V (beim TC1602E Vss=Gnd)
|-
! 3
| Vee || Kontrastspannung (0V bis 5V)
|-
! 4
| RS || Register Select (Befehle/Daten)
|-
! 5
| RW || Read/Write
|-
! 6
| E
| Enable
|-
! 7
| DB0 ||rowspan="8"| Datenbits 0−7
|-
! 8
| DB1
|-
! 9
| DB2
|-
! 10
| DB3
|-
! 11
| DB4
|-
! 12
| DB5
|-
! 13
| DB6
|-
! 14
| DB7
|-
! 15
| A || LED-Beleuchtung, Anode
|-
! 16
| K || LED-Beleuchtung, Kathode
|}

{{Warnung|
;Achtung: Unbedingt von der richtigen Seite zu zählen anfangen! Meistens ist neben Pin 1 eine kleine 1 auf der LCD-Platine. Ansonsten im Datenblatt nachschauen! Oft ist Pin 1 auch durch ein rechteckiges statt rundes Pad gekennzeichnet.

:Bei LCDs mit 16-poligem Anschluss sind die beiden letzten Pins für die Hintergrundbeleuchtung reserviert. Hier unbedingt das Datenblatt zu Rate ziehen, die beiden Anschlüsse sind je nach Hersteller oft anders beschaltet. Falls kein Datenblatt vorliegt, kann man mit einem Durchgangsprüfer feststellen, welcher Anschluss mit Masse (GND) verbunden ist.
}}

Vss wird ganz einfach an GND angeschlossen und Vcc an 5V. Vee kann man testweise auch an GND legen. Wenn das LCD dann zu dunkel sein sollte muss man ein 10k-Potentiometer zwischen GND und 5V schalten, mit dem Schleifer an Vee:

[[Bild:LCD_Vee.gif]]

Es gibt zwei verschiedene Möglichkeiten zur Ansteuerung eines solchen Displays: den '''8-bit-''' und den '''4-bit-'''Modus.
* Für den '''8-bit-Modus''' werden (wie der Name schon sagt) alle acht Datenleitungen zur Ansteuerung verwendet, somit kann durch einen Zugriff immer ein ganzes Byte übertragen werden.
* Der '''4-bit-Modus''' verwendet nur die oberen vier Datenleitungen ('''DB4-DB7'''). Um ein Byte zu übertragen braucht man somit zwei Zugriffe, wobei zuerst das höherwertige '''"Nibble"''' (= 4 Bits), also Bit 4 bis Bit 7 übertragen wird und dann das niederwertige, also Bit 0 bis Bit 3. Die unteren Datenleitungen des LCDs, die beim Lesezyklus Ausgänge sind, lässt man offen (siehe Datasheets, z. B. vom KS0070).

Der 4-bit-Modus hat den Vorteil, dass man 4 IO-Pins weniger benötigt als beim 8-bit-Modus, weshalb ich mich hier für eine Ansteuerung mit 4bit entschieden habe.

Neben den vier Datenleitungen (DB4, DB5, DB6 und DB7) werden noch die Anschlüsse '''RS''', '''RW''' und '''E''' (ist in manchen Unterlagen auch '''EN''' für ''Enable'' abgekürzt) benötigt.

* Über '''RS''' wird ausgewählt, ob man einen Befehl oder ein Datenbyte an das LCD schicken möchte. Ist RS Low, dann wird das ankommende Byte als Befehl interpretiert, ist RS high, dann wird das Byte auf dem LCD angezeigt.
* '''RW''' legt fest, ob geschrieben oder gelesen werden soll. High bedeutet lesen, low bedeutet schreiben. Wenn man RW auf lesen einstellt und RS auf Befehl, dann kann man das '''Busy-Flag''' an DB7 lesen, das anzeigt, ob das LCD den vorhergehenden Befehl fertig verarbeitetet hat (diese Methode u.a. in der LCD-Library von Peter Fleury verwendet). Ist RS auf Daten eingestellt, dann kann man z. B. den Inhalt des Displays lesen - was jedoch nur in den wenigsten Fällen Sinn macht. Deshalb kann man RW dauerhaft auf low lassen (= an GND anschließen), so dass man noch ein IO-Pin am Controller einspart. Der Nachteil ist, dass man dann das Busy-Flag nicht lesen kann, weswegen man nach jedem Befehl vorsichtshalber ein paar Mikrosekunden warten sollte, um dem LCD Zeit zum Ausführen des Befehls zu geben. Dummerweise schwankt die Ausführungszeit von Display zu Display und ist auch von der Betriebsspannung abhängig. Für professionellere Sachen also lieber den IO-Pin opfern und Busy abfragen.
* Der '''E''' Anschluss schließlich signalisiert dem LCD, dass die übrigen Datenleitungen jetzt korrekte Pegel angenommen haben und es die gewünschten Daten von den Datenleitungen bzw. Kommandos von den Datenleitungen übernehmen kann.

== Anschluss an den Controller ==

Jetzt da wir wissen, welche Anschlüsse das LCDs benötigt, können wir das LCD mit dem Mikrocontroller verbinden:

ACHTUNG: Es gibt Displays mit abweichender Anschluss-Belegung, falscher Anschluss kann zur Zerstörung führen! Daher immer das zugehörige Datenblatt zu Rate ziehen.

Einzelheiten unter [http://www.mikrocontroller.net/articles/HD44780 Artikel zum Controller HD44780]

{| class="wikitable"
!Pin #-LCD || Bezeichnung-LCD || Pin-µC
|-
!1
| Vss || GND
|-
!2
| Vcc || 5V
|-
!3
| Vee || GND oder Poti (siehe oben)
|-
!4
| RS || PD4 am AVR
|-
!5
| RW || GND
|-
!6
| E || PD5 am AVR
|-
!7
| DB0 ||rowspan="4"| offen (unbenutzt)
|-
!8
| DB1
|-
!9
| DB2
|-
!10
| DB3
|-
!11
| DB4 || PD0 am AVR
|-
!12
| DB5 || PD1 am AVR
|-
!13
| DB6 || PD2 am AVR
|-
!14
| DB7 || PD3 am AVR
|}

Wenn man die Steuerleitungen EN und RS auf Pins an einem anderen Port legen möchte, kann man so wie in diesem [http://www.mikrocontroller.net/topic/88543#751982 Forumsbeitrag] oder wie im Artikel [[Erweiterte LCD-Ansteuerung]] vorgehen.

Ok, alles ist verbunden, wenn man jetzt den Strom einschaltet sollten ein oder zwei schwarze Balken auf dem Display angezeigt werden. Erscheint trotz korrektem Anschluss nichts auf dem Display, so kann das auch am Kontrast des LCDs liegen. Die Balken werden dann zwar theoretisch angezeigt, sind aber nicht sichtbar, weil die Kontrastspannung zu hoch ist. Abhilfe schafft es hier, wenn man die Spannung am Schleifer des Potis nachmisst und in Richtung 0V verstellt. Zwischen 1V und 0V treten die Balken dann meist hervor.
Doch wie bekommt man jetzt die Befehle und Daten in das Display?

== Programmierung ==

=== Die LCD Routinen ===

Der folgende Satz von Ansteuerroutinen für ein Text-LCD ist in der Datei '''lcd-routines.c''' zusammengefasst. Diese Datei muss man beim Einrichten zusätzlich zum eigenen Hauptprogramm in sein Projekt aufnehmen. Dies geschieht beim AVR Studio unter Source Files im Fenster AVR GCC oder bei WinAVR im Makefile (z. B. durch SRC += lcd-routines.c).

Wichtig ist außerdem, dass die Optimierung bei der Compilierung eingeschaltet ist, sonst stimmen die Zeiten der Funktionen _delay_us() und _delay_ms() nicht und der Code wird wesentlich länger (Siehe Dokumentation der libc im WinAVR).

Als weitere Datei ist die Includedatei '''lcd-routines.h''' notwendig, die im Hauptprogramm und in '''lcd-routines.c''' eingebunden wird. Die Anpassung der Pinbelegung etc. macht man in dieser Datei.

==== Datei '''lcd-routines.h''' ====
<syntaxhighlight lang="c">
// Ansteuerung eines HD44780 kompatiblen LCD im 4-Bit-Interfacemodus
// http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung
//

#ifndef LCD_ROUTINES_H
#define LCD_ROUTINES_H

////////////////////////////////////////////////////////////////////////////////
// Hier die verwendete Taktfrequenz in Hz eintragen, wichtig!

#ifndef F_CPU
#define F_CPU 3686400
#endif

////////////////////////////////////////////////////////////////////////////////
// Pinbelegung für das LCD, an verwendete Pins anpassen
// Alle LCD Pins müssen an einem Port angeschlossen sein und die 4
// Datenleitungen müssen auf aufeinanderfolgenden Pins liegen

// LCD DB4-DB7 <--> PORTD Bit PD0-PD3
#define LCD_PORT PORTD
#define LCD_DDR DDRD
#define LCD_DB PD0

// LCD RS <--> PORTD Bit PD4 (RS: 1=Data, 0=Command)
#define LCD_RS PD4

// LCD EN <--> PORTD Bit PD5 (EN: 1-Impuls für Daten)
#define LCD_EN PD5

////////////////////////////////////////////////////////////////////////////////
// LCD Ausführungszeiten (MS=Millisekunden, US=Mikrosekunden)

#define LCD_BOOTUP_MS 15
#define LCD_ENABLE_US 20
#define LCD_WRITEDATA_US 46
#define LCD_COMMAND_US 42

#define LCD_SOFT_RESET_MS1 5
#define LCD_SOFT_RESET_MS2 1
#define LCD_SOFT_RESET_MS3 1
#define LCD_SET_4BITMODE_MS 5

#define LCD_CLEAR_DISPLAY_MS 2
#define LCD_CURSOR_HOME_MS 2

////////////////////////////////////////////////////////////////////////////////
// Zeilendefinitionen des verwendeten LCD
// Die Einträge hier sollten für ein LCD mit einer Zeilenlänge von 16 Zeichen passen
// Bei anderen Zeilenlängen müssen diese Einträge angepasst werden

#define LCD_DDADR_LINE1 0x00
#define LCD_DDADR_LINE2 0x40
#define LCD_DDADR_LINE3 0x10
#define LCD_DDADR_LINE4 0x50

////////////////////////////////////////////////////////////////////////////////
// Initialisierung: muss ganz am Anfang des Programms aufgerufen werden.
void lcd_init( void );

////////////////////////////////////////////////////////////////////////////////
// LCD löschen
void lcd_clear( void );

////////////////////////////////////////////////////////////////////////////////
// Cursor in die 1. Zeile, 0-te Spalte
void lcd_home( void );

////////////////////////////////////////////////////////////////////////////////
// Cursor an eine beliebige Position
void lcd_setcursor( uint8_t spalte, uint8_t zeile );

////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines einzelnen Zeichens an der aktuellen Cursorposition
void lcd_data( uint8_t data );

////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines Strings an der aktuellen Cursorposition
void lcd_string( const char *data );

////////////////////////////////////////////////////////////////////////////////
// Definition eines benutzerdefinierten Sonderzeichens.
// data muss auf ein Array[8] mit den Zeilencodes des zu definierenden Zeichens
// zeigen
void lcd_generatechar( uint8_t code, const uint8_t *data );

////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines Kommandos an das LCD.
void lcd_command( uint8_t data );

////////////////////////////////////////////////////////////////////////////////
// LCD Befehle und Argumente.
// Zur Verwendung in lcd_command

// Clear Display -------------- 0b00000001
#define LCD_CLEAR_DISPLAY 0x01

// Cursor Home ---------------- 0b0000001x
#define LCD_CURSOR_HOME 0x02

// Set Entry Mode ------------- 0b000001xx
#define LCD_SET_ENTRY 0x04

#define LCD_ENTRY_DECREASE 0x00
#define LCD_ENTRY_INCREASE 0x02
#define LCD_ENTRY_NOSHIFT 0x00
#define LCD_ENTRY_SHIFT 0x01

// Set Display ---------------- 0b00001xxx
#define LCD_SET_DISPLAY 0x08

#define LCD_DISPLAY_OFF 0x00
#define LCD_DISPLAY_ON 0x04
#define LCD_CURSOR_OFF 0x00
#define LCD_CURSOR_ON 0x02
#define LCD_BLINKING_OFF 0x00
#define LCD_BLINKING_ON 0x01

// Set Shift ------------------ 0b0001xxxx
#define LCD_SET_SHIFT 0x10

#define LCD_CURSOR_MOVE 0x00
#define LCD_DISPLAY_SHIFT 0x08
#define LCD_SHIFT_LEFT 0x00
#define LCD_SHIFT_RIGHT 0x04

// Set Function --------------- 0b001xxxxx
#define LCD_SET_FUNCTION 0x20

#define LCD_FUNCTION_4BIT 0x00
#define LCD_FUNCTION_8BIT 0x10
#define LCD_FUNCTION_1LINE 0x00
#define LCD_FUNCTION_2LINE 0x08
#define LCD_FUNCTION_5X7 0x00
#define LCD_FUNCTION_5X10 0x04

#define LCD_SOFT_RESET 0x30

// Set CG RAM Address --------- 0b01xxxxxx (Character Generator RAM)
#define LCD_SET_CGADR 0x40

#define LCD_GC_CHAR0 0
#define LCD_GC_CHAR1 1
#define LCD_GC_CHAR2 2
#define LCD_GC_CHAR3 3
#define LCD_GC_CHAR4 4
#define LCD_GC_CHAR5 5
#define LCD_GC_CHAR6 6
#define LCD_GC_CHAR7 7

// Set DD RAM Address --------- 0b1xxxxxxx (Display Data RAM)
#define LCD_SET_DDADR 0x80

#endif
</syntaxhighlight>

==== Datei '''lcd-routines.c''': ====
<syntaxhighlight lang="c">
// Ansteuerung eines HD44780 kompatiblen LCD im 4-Bit-Interfacemodus
// http://www.mikrocontroller.net/articles/HD44780
// http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung
//
// Die Pinbelegung ist über defines in lcd-routines.h einstellbar

#include <avr/io.h>
#include "lcd-routines.h"
#include <util/delay.h>

////////////////////////////////////////////////////////////////////////////////
// Erzeugt einen Enable-Puls
static void lcd_enable( void )
{
LCD_PORT |= (1<<LCD_EN); // Enable auf 1 setzen
_delay_us( LCD_ENABLE_US ); // kurze Pause
LCD_PORT &= ~(1<<LCD_EN); // Enable auf 0 setzen
}

////////////////////////////////////////////////////////////////////////////////
// Sendet eine 4-bit Ausgabeoperation an das LCD
static void lcd_out( uint8_t data )
{
data &= 0xF0; // obere 4 Bit maskieren

LCD_PORT &= ~(0xF0>>(4-LCD_DB)); // Maske löschen
LCD_PORT |= (data>>(4-LCD_DB)); // Bits setzen
lcd_enable();
}

////////////////////////////////////////////////////////////////////////////////
// Initialisierung: muss ganz am Anfang des Programms aufgerufen werden.
void lcd_init( void )
{
// verwendete Pins auf Ausgang schalten
uint8_t pins = (0x0F << LCD_DB) | // 4 Datenleitungen
(1<<LCD_RS) | // R/S Leitung
(1<<LCD_EN); // Enable Leitung
LCD_DDR |= pins;

// initial alle Ausgänge auf Null
LCD_PORT &= ~pins;

// warten auf die Bereitschaft des LCD
_delay_ms( LCD_BOOTUP_MS );

// Soft-Reset muss 3mal hintereinander gesendet werden zur Initialisierung
lcd_out( LCD_SOFT_RESET );
_delay_ms( LCD_SOFT_RESET_MS1 );

lcd_enable();
_delay_ms( LCD_SOFT_RESET_MS2 );

lcd_enable();
_delay_ms( LCD_SOFT_RESET_MS3 );

// 4-bit Modus aktivieren
lcd_out( LCD_SET_FUNCTION |
LCD_FUNCTION_4BIT );
_delay_ms( LCD_SET_4BITMODE_MS );

// 4-bit Modus / 2 Zeilen / 5x7
lcd_command( LCD_SET_FUNCTION |
LCD_FUNCTION_4BIT |
LCD_FUNCTION_2LINE |
LCD_FUNCTION_5X7 );

// Display ein / Cursor aus / Blinken aus
lcd_command( LCD_SET_DISPLAY |
LCD_DISPLAY_ON |
LCD_CURSOR_OFF |
LCD_BLINKING_OFF);

// Cursor inkrement / kein Scrollen
lcd_command( LCD_SET_ENTRY |
LCD_ENTRY_INCREASE |
LCD_ENTRY_NOSHIFT );

lcd_clear();
}

////////////////////////////////////////////////////////////////////////////////
// Sendet ein Datenbyte an das LCD
void lcd_data( uint8_t data )
{
LCD_PORT |= (1<<LCD_RS); // RS auf 1 setzen

lcd_out( data ); // zuerst die oberen,
lcd_out( data<<4 ); // dann die unteren 4 Bit senden

_delay_us( LCD_WRITEDATA_US );
}

////////////////////////////////////////////////////////////////////////////////
// Sendet einen Befehl an das LCD
void lcd_command( uint8_t data )
{
LCD_PORT &= ~(1<<LCD_RS); // RS auf 0 setzen

lcd_out( data ); // zuerst die oberen,
lcd_out( data<<4 ); // dann die unteren 4 Bit senden

_delay_us( LCD_COMMAND_US );
}

////////////////////////////////////////////////////////////////////////////////
// Sendet den Befehl zur Löschung des Displays
void lcd_clear( void )
{
lcd_command( LCD_CLEAR_DISPLAY );
_delay_ms( LCD_CLEAR_DISPLAY_MS );
}

////////////////////////////////////////////////////////////////////////////////
// Sendet den Befehl: Cursor Home
void lcd_home( void )
{
lcd_command( LCD_CURSOR_HOME );
_delay_ms( LCD_CURSOR_HOME_MS );
}

////////////////////////////////////////////////////////////////////////////////
// Setzt den Cursor in Spalte x (0..15) Zeile y (1..4)

void lcd_setcursor( uint8_t x, uint8_t y )
{
uint8_t data;

switch (y)
{
case 1: // 1. Zeile
data = LCD_SET_DDADR + LCD_DDADR_LINE1 + x;
break;

case 2: // 2. Zeile
data = LCD_SET_DDADR + LCD_DDADR_LINE2 + x;
break;

case 3: // 3. Zeile
data = LCD_SET_DDADR + LCD_DDADR_LINE3 + x;
break;

case 4: // 4. Zeile
data = LCD_SET_DDADR + LCD_DDADR_LINE4 + x;
break;

default:
return; // für den Fall einer falschen Zeile
}

lcd_command( data );
}

////////////////////////////////////////////////////////////////////////////////
// Schreibt einen String auf das LCD

void lcd_string( const char *data )
{
while( *data != '\0' )
lcd_data( *data++ );
}

////////////////////////////////////////////////////////////////////////////////
// Schreibt ein Zeichen in den Character Generator RAM

void lcd_generatechar( uint8_t code, const uint8_t *data )
{
// Startposition des Zeichens einstellen
lcd_command( LCD_SET_CGADR | (code<<3) );

// Bitmuster übertragen
for ( uint8_t i=0; i<8; i++ )
{
lcd_data( data[i] );
}
}
</syntaxhighlight>

=== LCD Beispiel 1 ===
Ein Hauptprogramm, welches die LCD Funktionen benutzt, sieht zb. so aus:

<syntaxhighlight lang="c">
//
// Anpassungen im makefile:
// ATMega8 => MCU=atmega8 im makefile einstellen
// lcd-routines.c in SRC = ... Zeile anhängen
//
#include <avr/io.h>
#include "lcd-routines.h"

int main(void)
{
// Initialisierung des LCD
// Nach der Initialisierung müssen auf dem LCD vorhandene schwarze Balken
// verschwunden sein
lcd_init();

// Text in einzelnen Zeichen ausgeben
lcd_data( 'T' );
lcd_data( 'e' );
lcd_data( 's' );
lcd_data( 't' );

// Die Ausgabemarke in die 2te Zeile setzen
lcd_setcursor( 0, 2 );

// erneut Text ausgeben, aber diesmal komfortabler als String
lcd_string("Hello World!");

while(1)
{
}

return 0;
}
</syntaxhighlight>

=== LCD Beispiel 2 ===
Ein Hauptprogramm, welches eine Variable ausgibt, sieht zb. so aus.
Mittels der itoa() Funktion (itoa = Integer To Ascii ) wird von einem Zahlenwert eine textuelle Repräsentierung ermittelt (sprich: ein String erzeugt) und dieser String mit der bereits vorhandenen Funktion lcd_string ausgegeben. Das Einrichten des Projekts ist wie in Beispiel 1.

<syntaxhighlight lang="c">
//
// Anpassungen im makefile:
// ATMega8 => MCU=atmega8 im makefile einstellen
// lcd-routines.c in SRC = ... Zeile anhängen
//
#include <avr/io.h>
#include <stdlib.h>
#include "lcd-routines.h"

// Beispiel
int variable = 42;

int main(void)
{
lcd_init();

// Ausgabe des Zeichens dessen ASCII-Code gleich dem Variablenwert ist
// (Im Beispiel entspricht der ASCII-Code 42 dem Zeichen *)
// http://www.code-knacker.de/ascii.htm
lcd_data( variable );

lcd_setcursor( 0, 2 );

// Ausgabe der Variable als Text in dezimaler Schreibweise
{
// ... umwandeln siehe FAQ Artikel bei http://www.mikrocontroller.net/articles/FAQ
// WinAVR hat eine itoa()-Funktion, das erfordert obiges #include <stdlib.h>
char Buffer[20]; // in diesem {} lokal
itoa( variable, Buffer, 10 );

// ... ausgeben
lcd_string( Buffer );
}

while(1)
{
}

return 0;
}
</syntaxhighlight>

== Siehe auch ==

* [[Erweiterte LCD-Ansteuerung]]
* [[Pseudo-Graphische LCD-Ansteuerung]]
*[http://www.mikrocontroller.net/topic/316826#3431235 Ermittlung der Startadresse der einzelnen Zeilen]

== Weblinks ==

* [http://homepage.hispeed.ch/peterfleury/avr-software.html#libs Lib zur HD44780 Ansteuerung (AVR)]
* [http://www.nongnu.org/avr-libc/user-manual/group__stdiodemo.html Using the standard IO facilities] - Demoprojekt zur Text-LCD Ansteuerung (HD44780 komp.) in der avr-libc

[[Kategorie:Avr-gcc Tutorial]]
[[Kategorie:LCD]]

POV-Display

2013-10-24T07:05:29Z

145.225.60.4:

In diesem Artikel wird die Realisierung eines POV-Displays (persistence of vision, siehe http://de.wikipedia.org/wiki/Nachbildwirkung) beschrieben.
Der besondere Effekt eines solchen Displays liegt darin, dass das Bild
erst durch die Trägheit des Auges entsteht. Bei Bauarten wie dieser
kann damit ein Bild mehr oder weniger schwebend in der Luft erzeugt werden.
Die Technik wird in verschiedensten Varianten eingesetzt, beispielhaft
wird hier ein Globus mit 40 RGB-[[LED]]s gezeigt.

Der Artikel soll vor allem Anregungungen zum Aufbau, zu speziellen
Details und Bauteilen bieten wie auch als Codegrundlage dienen.

[[Bild:globe_11_1024.jpg|right|300px]]

Demoanwendung mit einigen Animationen:
http://youtu.be/ziD_1fVdDWQ

== Randdaten ==
* 40 RGB LEDs, Bildfläche 80x40 Pixel mit 7 Farben (+ echtem Alphachannel)
* Globus mit 20cm Durchmesser
* ATMega644
* selbstregelnde Refresh-Rate über optischen Sensor
* ca. 1/2 ASCII-Text Support
* Bildkonverter

== Mechanische Konstruktion ==
Es gibt neben dem hier beschriebenen Rotor auch noch weitere Techniken wie
geschlitzte Abdeckungen.
=== Rotor ===
[[Bild:globe_04_1024.jpg|thumb|right|Trägerkonstruktion aus Alu]]
Grundsätzlich sind 3 Arten von Rotoren typisch: flach, zylindrisch und kugelförmig.
Zylindrische und flache Rotoren sind recht simpel zu bauen, wobei bei letzterem natürlich
noch der Softwareaufwand für die Umrechnung kartesisch->polar hinzukommt.
Kugelförmige Rotoren haben das Problem, dass es unter einer gewissen Groesse kaum möglich
ist, Treiber und LEDs auf eine Platine zu setzen. Mein Rotor war mit d=20cm dafür zu klein,
deshalb kommt hier eine etwas wüste, fliegende Konstruktion zum Einsatz.

Bei allen Rotoren ist natürlich auf eine mechanisch stabile Auslegung zu achten, besonders
bei größeren Durchmessern. Ein Rotor mit einem Durchmesser von 50cm hätte bei 25Hz bereits
eine Zentrifugalbeschleunigung von über 628g im Rand!
Dementsprechend wichtig ist auch das genaue Auswuchten des fertigen Rotors.

=== Antrieb ===
[[Bild:globe_12_1024.jpg|thumb|right|Innenaufnahme Gehäuse]]
Am besten würde sich natürlich ein Antrieb eignen, der seine Drehzahl sehr genau
halten kann, was aber zumindest eine entsprechende Regelstrecke voraussetzt.

Als einfache Alternative habe ich deshalb einen Speed 700BB 12V verwendet, der
für meinen Rotor ausreicht wenn er aktiv gekühlt wird.
Ein guter Richtwert für die Drehzahl sind etwa 20-25Hz.
Die statische Steuerung erfolgt über eine unspektakuläre [[PWM]] aus einem ATTiny45
und grossem [[FET]]. Da die Drehzahl bei dieser Methode nicht konstant ist,
wird eine Regelung der Bildwiederholrate notwendig.

=== Stromversorgung ===
[[Bild:globe_13_1024.jpg|thumb|right|Simpler Schleifkontakt]]
Die Stromversorgung des Rotors lässt sich am einfachsten über Schleifkontakte
bewerkstelligen. Wenn man auf eine Spannungsregelung auf der Controllerplatine
verzichten will muss die Spannung dort unbedingt gut gepuffert werden. Dazu mehr
im entsprechenden Abschnitt.

Ich habe 2 Schleifringe aus Messingrohr mit Epoxy aufgeklebt, gross genug
um darunter das Kabel des darunterliegenden Schleifrings verlegen zu können.
Die schwarze Kunststoffplatte drückt die 2 Schleifkontakte dagegen.
Man könnte natürlich kleinere Ringe nehmen und das 2. Kabel im Trägerrohr
verlegen.

Eine verschleiß- und geräuschfreie Alternative wären Induktionsspulen.

Als Stromquelle dient die 5V Schiene eines Computernetzteils.

=== Gehäuse ===
Das Gehäuse ist bei mir reines Mittel zum Zweck (wie man vermutlich sieht).
Ich habe dicke Spanplatten verbaut, um es verwindungssteif und gleichzeitig
schwer zu machen, da ein 100%iges Auswuchten fast unmoeglich ist.

== LEDs und Treiber ==
[[Bild:globe_06_1024.jpg|thumb|right|aussen LEDs, innen Schieberegister]]
Als LEDs kamen die verbreiteten RGB-LEDs der Bauform 5050 zum Einsatz, die sich
sehr gut in den Punkten Helligkeit, Abstrahlwinkel, Farbmischung und
Ansteuerbarkeit (keine gemeinsame Anode/Kathode) eignen.

Um die LEDs gleichmäßig aufzukleben habe ich einen Papierstreifen zugeschnitten,
mit Bleistift Markierungen gesetzt und diesen mit Sekundenkleber (getränkt) auf
den Ring aufgeklebt. Die LEDs wurden dann mit etwas Epoxy darauf geklebt.

Getrieben wird alles mit 15 Schieberegistern 74HC595, diese sind pro Farbe
auf jeweils 5 in Serie aufgeteilt. Siehe dazu den -> Schaltplan für eine
"Stufe" aus 8 LEDs, dort sind auch die entsprechenden Ausgangspins am
Atmel angegeben.
Da die Schieberegister auf Vcc und GND nur 70mA aushalten, habe ich den auch
schon im [[AVR-Tutorial: Schieberegister]] Trick angewendet und jeweils
4 LEDs mit Anoden links und 4 mit Kathoden links abgewechselt.

Dadurch treten allerdings 3 Effekte auf: Zum einen liegen die einzelnen Chips
in den LEDs nicht mehr exakt auf einer Linie, was bei genauerer Betrachtung bzw.
ohne zusätzlichen Diffusor auffällt.
Zum anderen muss das jeweilige Vertauschen von Blau und Grün entweder in der
Verkabelung oder im Code (meine Methode) beachtet werden, genau wie die
Tatsache, dass dann je 4 LEDs active high und 4 active low sind.
[[Bild:rotor_scheme.png|thumb|right|Schaltplan LEDs+Register]]
Versorgungs- und Steuerleitungen habe ich im Trägerrohr verlegt.
Nach dem Funktionstest habe ich die fliegende Konstruktion noch mit einer
entsprechenden Menge Epoxy vergossen.

== Controllerplatine ==
[[Bild:povglobe_scheme.png|thumb|right|Schaltplan Controllerplatine]]
Die Controllerplatine befindet sich im Gehäuse und ist sehr simpel gehalten,
sie beinhaltet im wesentlichen den ATMega644 mit ISP-Header und Anschlüssen für die
Schieberegister, einer Pufferung für die Versorungsspannung und 2 OPAMP-Stufen,
die mit einer Fotodiode + Schmitt-Trigger den externen Interrupt aktivieren.
Die Pufferung ist wichtig, da die Schleifkontakte keine saubere Versorgung
gewährleisten können.

Zu meiner Dektektorschaltung noch ein Hinweis: Am besten vorher am Breadboard
die Werte prüfen und danach auch am Controller testen ob die Triggerung auf
steigende oder fallende Flanke besser funktioniert. Ausserdem könnte man noch
einen kleinen Kondensator parallel zu R9 schalten (Tiefpass).

Layout und der Bestückungsplan (von Kupferseite aus gesehen) finden sich im .tgz.
Auch die Platine sollte ausgewuchtet werden.

== Firmware ==
Die Firmware für den [[AVR-GCC]] geschrieben worden.
Als Buffer für das aktuelle Bild dient das uint8_t globe[80][5][3] Array,
welches in x-Position (in Drehrichtung), Zeile und Farbindex unterteilt ist.
Das Byte repräsentiert die 8 vertikalen Bits einer Zeile, ähnlich wie bei einem
graphischen LCD.

=== Anpassung der Bildwiederholrate ===
Ich habe den 16bit-Timer-Overflow als Zeitgeber missbraucht, der im Sollfall
320x (80 x-Werte x4) so schnell auslöst wie die Rotordrehzahl. Die vierfache
Zählgeschwindigkeit dient dabei der Anpassung der Geschwindigkeit an die
tatsächliche Drehzahl.
Bei jedem 4. Timerüberlauf wird dann der entsprechende Längengrad auf die Register geschoben.
Die [[ISR]] ist natürlich sehr lang, dafür muss aber bei komplexeren Transformationen/Animationen
nicht auf Laufzeiten geachtet werden. Wichtig dabei: Alle anderen Operationen werden als nicht
zeitkritisch betrachtet.

Eine weitere ISR wird beim Auftreten des Detektorinterrupts ausgelöst. Diese setzt
Index und Zählerregister zurück und korrigiert die Wiederholrate anhand des
tatsächlich erreichten Index.

== Bildkonverter ==
Um ganze Bilder, wie z.B. die Weltkarte einfach auf den Globus zu bekommen, habe ich
einen kleinen quick&dirty (!) Bildkonverter mit perl und perl-imagemagick geschrieben, der
direkt einen passenden Header (PROGMEM) generiert. Das Script befindet sich ebenfalls
im .tgz und sollte hoffentlich mit perl auch unter Windows funktionieren.
Ein Bild benötigt etwas über 1,2kB Flash. In der animations.c befindet sich die
passende Ladefunktion + Beispielaufruf.

Es sei darauf hingewiesen, dass das Programm ungefragt die Zieldateien überschreibt!
Erwartet wird 80x40pix Bild, am besten als .bmp.

Im Script oben können die Schwellenwerte für die Farben eingestellt werden
(0-1, Werte >1 blenden die Farbe komplett aus), dazu wird noch ein Bild generiert, um
diese Werte testen zu können, ohne es live auf dem Globus ausprobieren zu müssen.

Aufruf: img2globe.pl image.bmp <Name des Arrays>

== Was aufgefallen ist/weitere Hinweise ==
* Zur Videoaufnahme: Es ist recht schwer richtige Lichtverhältnisse zu finden, da die Kamera ständig nachregeln will. Beste Erfahrungen habe ich mit sehr viel Licht gemacht. Ausserdem sollte dazu die Drehzahl etwas hochgefahren werden, um schwarze Balken zu vermeiden.
* Der Atmel ist mal wieder sehr an seiner Grenze. Würde ich nochmal einen Globe bauen, käme vermutlich ein Cortex-M3 rein.

== Downloads & Links ==
Projektseite auf meiner Website:
* http://leyanda.de/light/povglobe.php
* [http://www.leyanda.de/light/files/povglobe_v10.tgz Source, Schaltpläne, Layout etc.]
[[Category:AVR-Projekte]]
[[Category:Displays und Anzeigen]]

Latch

2013-10-22T06:58:54Z

145.225.60.4:

[[Datei:Transparent Latch Symbol.svg|thumb|D-Latch]]
Ein Latch (engl. für ''Schnappschloss'', ''Auffangregister'') hat zwei Eingänge (D - Data und E - Enable) und einen Ausgang (Q). Solange E aktiv ist, wird D auf Q durchgeschaltet. Sobald E inaktiv wird, speichert Q den letzen Zustand an D. Ein Latch ist ein zustandsgesteuertes Speicherelement.

Die ICs 74xx373 und 74xx573 enthalten jeweils 8 Latches mit einer gemeinsamen Enable-Leitung. Mit diesen ICs kann man eine Porterweiterung vornehmen, beispielsweise um einen gemultiplexten Adress-/Datenbus anzusteuern.

In Digitalschaltungen in FPGAs oder CPLDs müssen Latches möglichst vermieden werden, da sie ungünstigere Eigenschaften bezüglich des Zeitverhaltens aufweisen als [[FlipFlop]]s.

{| {{Tabelle}} style="text-align:center"
|+ <big>'''Wahrheitstabelle für D-Latch'''</big>
! colspan="2" | Eingänge
!
! Ausgang
|-
! D
! E
!
! Q
|-
|L || H || || L
|-
|H ||H || ||H
|-
|x ||L || ||Q0
|-
|}

[[Category:Bauteile]]

AVR Net-IO Bausatz von Pollin

2012-02-20T14:04:36Z

145.225.60.4: /* AVR Net IO */

Hier steht eine Beschreibung des Pollin Bausatzes [http://www.pollin.de/shop/shop.php?cf=detail.php&pg=NQ==&a=MTQ5OTgxOTk= AVR-NET-IO. Best.Nr. 810 058], oder als aufgebautes Fertigmodul, Best.Nr. 810 073.

Einige Features: Ethernet-Platine mit ATmega32 und Netzwerkcontroller ENC28J60. Die Platine verfügt über 8 digitale Ausgänge, 4 digitale und 4 ADC-Eingänge, welche alle über einen Netzwerkanschluss (TCP/IP) abgerufen bzw. geschaltet werden können.

[[Datei:AVR-NET-IO ADD-ON.JPG|thumb|right|400px|AVR-NET-IO (links) mit zusätzlicher SUB-D Anschlussplatine (rechts, nicht im Lieferumfang)und Add-On-Board (oben, mit aufgelötetem RFM12-433-Modul, beides nicht im Lieferumfang). Ebenso ist zusätzlich ein nicht im Lieferumfang enthaltener kleiner Kühlkörper auf einem der Spannungsregler montiert und die Schraubklemmen zur Stromversorgung wurden durch Buchsen ersetzt.]]

== Technische Daten ==

* Betriebsspannung 9 V AC/DC
* Stromaufnahme ca. 190 mA
* 8 digitale Ausgänge (0/5 V) [PC0-PC7 an J3]
* 4 digitale Eingänge (0/5 V) [PA0-PA3 an J3]
* 4 ADC-Eingänge (10 Bit) [PA4-PA7 an Schraubklemmen]
* LCD-Anschluss (HD44780 komp. Controller nötig) [PD2-7,PB0,PB3 an EXT]
* [[ENC28J60]]
* [http://www.atmel.com/dyn/Products/Product_card.asp?part_id=2014 ATmega32] Mikrocontroller

Maße (L×B×H): 108×76×22 mm.

== Hardware ==

Die Schaltung des AVR-NET-IO ist recht einfach:
* Ein ATmega32 Mikrocontroller enthält die gesamte Software
* Ein ENC28J60 Ethernet-Controller für das Senden und Empfangen von Ethernet Frames (MAC und PHY Ethernet Layer) ist über [[SPI]] mit dem ATmega32 verbunden
* Ein Ethernet RJ-45 MagJack TRJ 0011 BA NL von [http://www.trxcom.com/ Trxcom] mit eingebautem Übertrager und Anzeige-LEDs am ENC28J60.
* Ein MAX232 für die serielle Schnittstelle
* Zwei Spannungsregler, 5 V und 3,3 V
* "Hühnerfutter"

Fast alle I/O Pins des ATmega32 sind irgendwo auf Anschlüssen herausgeführt. Entweder auf dem SUB-D Stecker, dem EXT oder ISP Wannensteckern oder den blauen Anschlussklemmen. Eine Schutzbeschaltung gibt es nicht.

Die blauen Anschlussklemmen haben eine Nut und eine Feder mit denen man
sie zusammenstecken kann, dadurch ist das Anlöten wesentlich leichter
und sie stehen auch sauber in der Reihe.

=== Erweiterungsplatine ===

Seit Januar 2010 gibt es auch eine Erweiterungsplatine

[http://www.pollin.de/shop/dt/Nzg4OTgxOTk-/Bausaetze/Diverse/Bausatz_Add_on_fuer_AVR_NET_IO.html Add-on für AVR-NET-IO-Board Best.Nr. 810 112]

Diese Platine erweitert das NET-IO um:

* SD-Karten-Slot über SPI
* Display über PCF 8574
* Infrarot
* [[RFM12]] Funkmodul (nicht im Lieferumfang enthalten)

Ausserdem soll es die 3.3V Versorgung der Hauptplatine verbessern. Dazu sollte man einen 4,7 kOhm Widerstand parallel zu R2 schalten. Sonst beträgt die Ausgangsspannung nur ca. 2,8V. (Tipp aus dem u.g. Thread im Forum)

Um bei einem Neuaufbau parallele Widerstände zu vermeiden, sollten folgende Änderungen auf dem Addon-Board gemacht werden:
*R2 1,5kΩ ersetzen mit 2kΩ
*R3 1,8K ersetzen mit 3,3kΩ
*R19 470kΩ ersetzen zu 470Ω
*Q1 BC548 ersetzen durch BC327 oder BC328 (Hauptsache PNP! und mehr als 100mA)

Stand Feb. 2011: R2 wird mit 2,2kΩ und R3 wird mit 3,6kΩ ausgeliefert. Somit werden die 3,3 V richtig erzeugt. R19 hat 470Ω.
Der ISP-Anschluß ist nicht vollständig durchgeschleift, es besteht keine Verbindung der RESET-Leitung zwischen ISP und ISP1 (Abhilfe: Drahtbrücke einlöten, [http://www.mikrocontroller.net/topic/161354#1600385 Quelle]).

Stand Nov. 2011: bei mir ist die RESET-Leitung korrekt zw. ISP und ISP1 verbunden. Es gibt jetzt auch einen R24 (470Ohm) und R11 (1KOhm), der in der bei mir mitgelieferten Bauanleitung fehlt, in der zum Download (V1.1) angebotenen aber drin steht.
Es wird immer noch der falsche Q1 BC548C (NPN) mitgeliefert. Das Schaltsymbol für einen PNP ist richtig im Schaltplan gezeichnet.

Stand Dez. 2011: '''R24''' (470Ohm) sollte mit 0 Ohm ersetzt
und '''R11''' (1KOhm) völlig weggelassen werden! 
Diese Widerstände bilden einen überflüssigen Spannungsteiler in der MISO Leitung. 
[http://son.ffdf-clan.de/include.php?path=forumsthread&threadid=1167&postid=9203 Fehler im Add-On V1.1]

Erste Erfahrungsberichte im Forum http://www.mikrocontroller.net/topic/161354

=== Hardware-Umbauten & -Verbesserungen ===

* Kühlkörper auf dem 7805 - (Vorsicht: Der LM317T ist rückseitig spannungsführend. Den Kühlkörper also keinesfalls an beide Spannungsregler anschließen!)
* MAX232 nach anfänglicher Konfiguration nicht bestücken um Strom zu sparen oder um zwei weitere I/O-Pins zu gewinnen
* 10µF-Elkos für MAX232N (C14-C17) durch 1µF ersetzen. Eine 10µF-Version für den MAX232 gibt es nicht. Die 10µF-Elkos können auch Ursache einer nicht funktionierenden RS232 sein.
** Laut Spezifikation sind auch mehr als 1µF erlaubt. Selbst Atmel verwendet beim STK500 10µF. Dies führt keinesfalls dazu, dass die RS232 nicht mehr funktioniert.
* Die IC-Fassungen aus "Pollins Resterampe" durch Fassungen mit gedrehten Kontakten ersetzen.
* ''Netz'' LED nicht bestücken oder größere Widerstände einlöten um Strom zu sparen (R3)
* Vorwiderstände der Ethernet-LEDs größer machen (z. B. verdoppeln) um Strom zu sparen (R6,R7)
* Linear-Spannungsregler ersetzen
* Kondensator an AREF-Pin des ATmega32 (ATmega32 Datenblatt) (100nF gegen Masse)
* Kondensator an den RESET-Pin des ATmega32 ([http://www.atmel.com/dyn/resources/prod_documents/doc2521.pdf Atmel Application Note AVR042: AVR Hardware Design Considerations]) Wenn man diese Quelle genauer liest, ist das aber eher unnötig. - Kondensator bei selbstbau-ISP empfehlenswert.
* Umbau auf 3,3 V:
** Ersatz der Spannungsregler durch einen einzigen 3,3 V Regler
** Anpassen (verkleinern) des LED-Vorwiderstands R3 für 3,3 Volt Betrieb
** Reduktion der Taktfrequenz (Austausch von Q2) auf den bei 3,3V erlaubten Bereich des ATmega32 ( ATmega32(L) 3.3V /8.0 Mhz Takt )
** Ersatz des MAX232 durch einen MAX3232
[[Bild:POWER.JPG|thumb|400px|5V Stromversorgung über USB Kabel, ohne 5 V Spannungsregler und Gleichrichterdioden, Vorsicht: kein Verpolungsschutz! ]]
* ATmega32 vom ENC28J60 takten (OSC2)
* Betrieb mit Gleichspannung:
** Dioden D2 und D5 durch Drahtbrücken ersetzen, D1 und D4 nicht bestücken (komplette Entfernung des Brückengleichrichters, beinhaltet Verlust des Verpolungsschutzes)
** Diode D2 bestücken, D5 durch Drahtbrücke ersetzen, D1 und D4 nicht bestücken (Brückengleichrichter durch Verpolungsschutze ersetzen)
*** ??? Ist dies nicht kontraproduktiv? Bei mir wurde durch D2-Bestückung die Eingangsspannung von ca. 5,2 V am LM317T auf ca. 4,6 V gedrückt, so dass am ENC28J60 nur ca. 2,6 V ankamen (außerhalb der lt. Datenblatt "Operating voltage range of 3.14V to 3.45V"). Man müsste also ein geregeltes Netzteil mit ca. 5,5 V anschließen um 5 und 3,3 V zu erzielen. Dann lieber den Verpolungsschutz durch andere Maßnahmen sicherstellen.
** Beim Betrieb von USB beachten, dass USB-Spezifikation keinesfalls 5V garantiert, sondern Spannung bis runter 4.4V erlaubt und dann u.U. durch den LM317 nicht mehr genügend Spannung am ENC anliegt. Das äußert sich so, dass zwar der Atmega einwandfrei funktioniert, die Ethernet-Kommunikation aber nicht oder nur sehr sporadisch.
* Ersatz des ATmega32 durch einen ATmega644 oder ATmega1284p mit mehr FLASH-Speicher.
* 100nF über alle drei IC Störunterdrückung zusätzlich bestücken

== Inbetriebnahme der Originalsoftware ==
=== Einleitung ===

Die bei Auslieferung (Stand September 2008) in den ATmega32 gebrannte Firmware stellt sich manchmal recht zickig an. Es scheint dann die Netzwerk-Schnittstelle, ggf. auch die seriell Schnittstelle, nicht zu funktionieren. Falls es Probleme geben sollte, sollte man erst einmal einen Firmwareupdate versuchen. Dies geschieht über die serielle Schnittstelle mittels des Programmes NetServer (aktuelle Version 1.03, Februar 2010), die dem Bausatz beiliegt.

Falls die serielle Schnittstelle ebenfalls nicht zugänglich ist, kann mit den im folgenden beschriebenen Schritten die Inbetriebnahme der Software möglich sein. Dazu benötigt man:

* Einen Windows-PC mit Ethernet-Schnittstelle und RS232-Schnittstelle (ein Prolific RS232-USB Konverter funktioniert)
* Entweder
**zwei normale (''straight through'') Ethernet-Kabel und einen Ethernet Switch/Hub, oder
**ein gekreuztes(''cross over'') Ethernet-Kabel
* Einen AVR Programmer (Hardware und Software). Zum Beispiel einen [[AVR Dragon]] oder [[STK500]] mit [[AVR Studio]] oder das [[Pollin ATMEL Evaluations-Board]] und [[avrdude]].
* Die [http://www.pollin.de/shop/ds/MTQ5OTgxOTk-.html Pollin NetServer Software], Version 1.03 (oder neuer)

=== Gelieferten ATmega32 richtig einstellen ===
[[image:fuse_bits_avr_studio.jpg|thumb|right|250px|Einstellungen der Fuse-Bits mittels AVR Studio 4]]
Die Fuses der gelieferten ATmega32s scheinen nicht immer mit den im Handbuch auf Seite 12 als erforderlich angegebenen Fuse-Einstellungen übereinzustimmen.

Dies kann man mittels eines Programmers ändern. LFuse = 0xBF, HFuse = 0xD2. Das genaue Vorgehen hängt dabei vom verwendeten Programmer ab. Bei der Gelegenheit kann man ebenfalls eine Sicherheitskopie des ursprünglichen Flash-Inhalts und des EEPROMs anfertigen. Das EEPROM scheint die MAC-Adresse des Ethernet-Ports zu enthalten.

Entgegen der Spezifikation im Handbuch von Pollin sollten die '''HFuses auf 0xC2''' gesetzt werden, d. h. CKOPT-Fuse programmiert (dies ist in der Software Version 1.03 bereits vollzogen). Das sorgt für einen stabilen Betrieb des AVR-Oszillators im "full rail-to-rail swing"-Mode bei 16 MHz. Atmel garantiert ansonsten nur stabilen Betrieb bis 8 MHz. Siehe ATmega32-Datenblatt, Kapitel 8.4, Crystal Oscillator.
{{Absatz}}

==== Funktionsfähige Konfiguration - AVR-Prog ====

[[Bild:Avrprog.png|thumb|right|250px]]
Benutzer von AVR-Prog können die nachfolgenden Einstellungen für die Lock- und Fuse-Bits verwenden. Hierbei handelt es sich um die ausgelesenen Einstellungen eines funktionsfähigen Controllers. Allerdings sollte, laut Handbuch des AVR-NET-IO-Boards, das Fuse-Bit EESAVE eigentlich gesetzt sein.

Alternativ kann auch per avrdude die Einstellung getroffen werden:
avrdude -c stk500v2 -pm32 -U lfuse:w:0xBF:m
und
avrdude -c stk500v2 -pm32 -U hfuse:w:0xC2:m

Anschließend muß noch der Bootloader und die Firmware aktualisiert werden (siehe Handbuch AVR-NET-IO-Board Seite 12 Punkt 3).

=== PC Konfiguration ===

==== PC normalerweise nicht im 192.168.0.0/24 Subnetz ====

Betreibt man den PC nicht im 192.168.0.0/24 Subnetz, muss er wie folgt umkonfiguriert werden, oder die IP Adresse des Boards wird entsprechend angepasst. ( Siehe Handbuch Seite 14ff. Das ist meist sinnvoller und auch einfacher. )

Den PC vom normalen Netzwerk abstecken[1]. Zur Umkonfiguration dazu bei Windows XP in der Systemsteuerung ''Netzwerkverbindungen'' aufrufen und die lokale ''LAN-Verbindung'' markieren. Dann in der rechten Leiste ''Einstellungen dieser Verbindung ändern'' aufrufen.

Es erscheint der Dialog ''Eigenschaften von <Verbindungsname>''. In der Liste im Dialog zu ''Internetprotokoll (TCP/IP)'' gehen. Ein Doppelklick auf den Eintrag öffnet den ''Eigenschaften von Internetprotokoll (TCP/IP)'' Dialog.

In diesem Dialog ''Folgende IP-Adresse verwenden:'' auswählen und zum Beispiel

IP-Adresse: '''192.168.0.100''' 
Subnetzmaske: '''255.255.255.0''' 
Standardgateway: '''192.168.0.1'''

eingeben.

Anmerkung von bitman:
[1] Dies ist spätestens ab Windows XP nicht mehr notwendig, wenn das Netz 192.168.0.0/24 noch frei ist. Dann kann man einfach den Client ''zusätzlich'' in diesem Netzwerk zusätzlich einbinden über Einstellungen/Netzwerkverbindungen/Lanverbindung/Eigenschaften/TCP-IP/Eigenschaften/Erweitert/IP-Adresse hinzufügen. Es werden dann eben mehrere IP-Adressen an den NIC gebunden.

Alle geöffneten Dialoge nacheinander mit OK schließen.

Alternativ bietet sich das Umprogrammieren des Boards über die serielle Schnittstelle an. Die Werte für IP-Adresse, Netzmaske und Standard-Gateway werden mit den dokumentierten SETxx-Befehlen geändert, das Board neu gestartet und ans vorhandene Netzwerk gesteckt.

Im EEPROM sind folgende Werte vorprogrammiert: 
3EE - 3F3 MAC-ADRESSE 
3F4 - 3F7 GATEWAY 
3F8 - 3FB NETMASK 
3FC - 3FF IP-ADRESSE 

==== PC bereits im 192.168.0.0/24 Subnetz ====

In diesem Fall muss man prüfen, ob die IP-Adresse 192.168.0.90 bereits im Subnetz verwendet wird. Ist dies der Fall, muss das verwendete Gerät mit dieser IP vorübergehend aus dem Subnetz entfernt werden. Es sei denn, dabei handelt es sich um den PC. In diesem Fall muss er wie zuvor umkonfiguriert werden. Ansonsten kann der unverändert im Netz verbleiben.

Dem AVR-NET-IO gibt man eine neue, zuvor unbenutzte Adresse (siehe unten). Dann kann das abgekoppelte Gerät wieder angeschlossen werden, beziehungsweise der PC zurückkonfiguriert werden.

=== AVR-NET-IO anschließen ===

Musste man den PC umkonfigurieren, so werden jetzt nur der PC und der AVR-NET-IO über Ethernet miteinander verbunden. Je nach Ethernet-Kabel benötigt man dazu einen Switch/Hub oder nicht.

Musste man den PC nicht umkonfigurieren, so kann man den AVR-NET-IO wie einen normalen Rechner an das vorhandenen Netz anschließen.

Zusätzlich schließt man die serielle Schnittstelle des AVR-NET-IO an den PC an.

=== Firmware 1.03 einspielen ===

Laut Handbuch sollte der AVR-NET-IO jetzt über Ethernet funktionieren. Ebenso sollte er über die serielle Schnittstelle und ein Terminalprogramm konfigurierbar sein. Beides ist offensichtlich im Auslieferungszustand selten der Fall.

Auch wenn sich Pollins NetServer Software nicht mit dem AVR-NET-IO verbinden lässt, so ist sie jedoch in der Lage eine neue Firmware 1.03 einzuspielen. Das Vorgehen ist im Handbuch auf Seite 12 beschrieben. NetServer präsentiert dabei ein paar einfache Anweisungen denen man folgen sollte.

Wenn sich nach dem scheinbar erfolgreichem Einspielen der Firmware, später nichts tut, so sollte die Firmware mit gesetztem "FailSafe" in der mitgelieferten NetServer-Software nochmals Eingespielt werden.

=== Abschluss ===

Jetzt sollte sich die NetServer Software mit dem AVR-NET-IO über Ethernet verbinden lassen. Dies macht es wiederum möglich, den AVR-NET-IO mit einer anderen IP-Adresse zu versehen. Will man den AVR-NET-IO in einem anderen Subnetz betreiben kann man dies jetzt einstellen.

Nachdem man die IP-Adresse neu eingestellt hat, muss man den PC zurückkonfigurieren und kann dann sowohl den AVR-NET-IO und den PC zusammen betreiben.

== Bekannte Fehler ==

Siehe auch [[#Hardware-Umbauten_.26_-Verbesserungen|Hardware-Umbauten und Verbesserungen]] 
Käufer berichten von fehlenden Bauteilen im Bausatz (Wannenstecker, Widerstände, Kondensatoren, Induktivitäten). Für Reklamationen: [https://www.pollin.de/shop/kontakt_service/reklamation.html]

* Die Stückliste auf Seite 4 in den Anleitung mit den Versionsangaben
** ''Stand 20.08.2008, kloiber, #1100, wpe'' (gedruckt im Bausatz)
** ''Stand 20.08.2008, cd, #all, wpe'' (auf der CD)
:ist falsch. Pollin legt dem Bausatz irgendwann ab September 2008 einen gedruckten Korrekturzettel bei. Die Online-Version der Anleitung ist korrigiert.
* Im Schaltplan auf Seite 7 in den Anleitungen mit den Versionen
** ''Stand 20.08.2008, kloiber, #1100, wpe'' (gedruckt im Bausatz)
** ''Stand 20.08.2008, cd, #all, wpe'' (auf der CD)
** ''Stand 03.09.2008, online, #all, wpe'' (Online)
:ist eine 25-polige SUB-D Buchse gezeichnet. Geliefert wird und in der Stückliste verzeichnet ist ein Stecker.

* Die September 2008 ausgelieferte Firmware im ATmega32 funktioniert bei vielen nicht und muss erst upgedatet werden (siehe [[#Inbetriebnahme der Originalsoftware|Inbetriebnahme der Originalsoftware]])

* Im Flash der gelieferten AVR ist anders als beschrieben nur der Bootloader enthalten, die eigentliche Firmware muss erst mit Hilfe der Updatefunktion geladen werden. Wenn zusätzlich auch die Fuses falsch gebrannt sind, dann funktioniert das Update nicht, auch wenn das PC Programm was anderes behauptet.

* Die Fuse-Einstellungen des ausgelieferten ATmega32 entspricht nicht der Anleitung (siehe [[#Inbetriebnahme der Originalsoftware|Inbetriebnahme der Originalsoftware]])

* Bausatz, gekauft am 27.10.08, Anleitungsversion 19.09.08, ohne Probleme oder erkennbare Fehler zusammengebaut und in Betrieb genommen.

* Bausatz gekauft 29.09.2008, Pinbelegung des 25 poligen D-Sub "Anschlusses" stimmt nicht mit der Anleitung überein. Der Aufdruck auf der Platine ist falsch. Pin1 <-> Pin13, Pin2 <-> Pin12 usw. Setzt man den D-Sub Stecker ein, so sind dessen Pinnummern korrekt. Bei einem Bausatz gekauft 10/2010 ist dies ebenfalls noch der Fall.

* 3 Bausätze Anf. Oktober 2008 gekauft, bei einem waren 2 LM317 dabei, dafür fehlte der 7805 - aus der Bastelkiste ersetzt. Alle haben jedoch auf Anhieb funktioniert

* Bausatz gekauft Ende Januar 2009. Die Lock-Bits (u.a. für PonyProg2000) werden falsch beschrieben. Die in Klammern aufgeführten Werte stimmen bei einem Bit nicht. Die Texte "Programmiert/Unprogrammiert" hingegen schon. Bei den Bauteilen gab es 4 Kondensatoren mit der Aufschrift "220", ich habe diese durch welche mit 22p ersetzt, da ich nicht sicher war ob wirklich 22p geliefert wurden. Dafür wurden statt einem zwei 7805 und statt einem mindestens vier LM317 mitgeliefert.

* Bausatz geliefert 22.4.2009. Alles vollständig, zusammengebaut, läuft. Software-Version 1.03. Für den oben schon genannten Steckverbinder wurde eine Buchse geliefert. Allerdings stimmen die PIN-Nummern im Schaltplan nicht mit den PIN-Nummern auf der Buchse überein (sie sind gespiegelt), daher liefen die Test-LEDs zunächst nicht.

* Bausatz geliefert 11.7.2009. Spannungsregler LM317T fehlt, grüne statt roter LED. Ein Kondensator 22pF zu viel. LM317T wurde auf Anfrage kostenlos nachgeliefert (27.7.). Inbetriebnahme problemlos.

* Bausatz geliefert 24.7.2009. Ein Quarz 16MHz zu viel, ebenfalls grüne statt rote LED.

* Bausatz geliefert 20.08.2009. Ein Kondensator 22pF zuviel und grüne statt rote LED.

* Bausatz Juli '09 gekauft, grüne statt rote LED

* Bausatz 25.09.09 geliefert, grüne Betriebs-LED, ein ELKO zuviel, Fehler 1µF am MAX232 statt 100nF behoben, richtiger C wird mitgeliefert, Aufbau komplett nach Pollin Anleitung durchgeführt, auf Anhieb fehlerfrei!

* Bausatz 17.10.09 geliefert, grüne Betriebs-LED, zwei 100nF Kondensatoren zu wenig. Aufbau und Inbetriebnahme problemlos.

* Bausatz 21.10.09 gekauft, grüne Betriebs-LED. Aufbau problemlos, RS232 läuft nicht. LAN läuft

* Bausatz Nov. 09 gekauft, grüne LED, alles o.k.

* Bausatz Nov. 09 gekauft, grüne LED, ENC28J60, MAX232 und ATmega32 fehlen, Nachlieferung nach einer Woche

*Bausatz Nov. 09 gekauft,Bauteile komplett.Verbindungsaufbau Seriell klappt erst nach mehreren Versuchen.Problem gelöst:Spannung an MAX und Mega zu niedrig

* Bausatz Dez. 09 gekauft, grüne LED, 100µF Kondensator fehlt, alles o.k.

* Bausatz August 09 gekauft, alle teile da nach Einstellen der fusebits lief alles perfekt

* Bausatz Okt. 09 gekauft, ein 100nF Kondensator und 25MHz Quarz fehlten ... hab beim lokalen Elektronikhändler keinen 25Mhz Grundton Quarz sondern nur im 3. Oberton bekommen aber mit R2.2k parallel zum Quarz schwingt er in der Schaltung schön bei 25Mhz. Mit 1µF am MAX232 funktioniert jetzt auch die RS232.

* 2x Bausatz Feb. 10 gekauft, bei beiden fehlten 7805, L1+L2 je 100µH sowie 4x falscher Wert Kondensator an Max232 vorhanden. Fehlende Bauteile nachgelötet und Funktion getestet. Hat alles einwandfrei funktioniert!!!

* Bausatz März. 10 gekauft, RS232 Printbuchse fehlt, dafür 1x 10pol Wannenstecker zuviel. Grüne LED statt Rot. Funktioniert ansonsten einwandfrei.

* Bausatz Jan. 10 gekauft, gelbe LED statt rot, C14...C17: 10µF, weder seriell noch via Ethernet Konnektivität. Nach Austausch von C14-C17 gegen 1µF, wenigstens serielle Kontaktaufnahme möglich, kein Ethernet auch nach Flash von 1.03 mit NetServer.

* Bausatz Feb. 10 gekauft, Spannungsregler LM317T fehlte

* Bausatz März 10 gekauft, gelbe statt rote LED geliefert, aber Aufbau und inbetriebnahme lt. Handbuch ohne Probleme

* Bausatz März 10 gekauft und gelbe statt rote LED geliefert, funzt wunderbar gemäß Anleitung

* Fertig gelötete Platine gekauft. µC war falsch im Sockel.

* Bausatz April 10 gekauft und gelbe statt rote LED geliefert, ADM232LJN statt MAX232 - Funktion erst nach Ersetzung des ADM durch nen MAX

* Bausatz April 10 gekauft und gelbe statt rote LED geliefert, ADM232LJN statt MAX232 - funktionierte sofort auch mit dem ADM232LJN.

* Bausatz April 10 gekauft wurde mit grüner statt roter LED Ausgeliefert

* Bausatz Juni 10 gekauft: wurde mit grüner statt roter Netz-LED ausgeliefert, 2x 22pF Kerko zuviel

* Bausatz August 10 gekauft: komplett und sofort funktioniert
* Bausatz Juli 10 gekauft: 2 Quarze mit 16 MHz geliefert, statt 1x 16MHz und 1x25MHz.
* Bausatz September 10 gekauft: hat sofort funktioniert. 1x 3,3k und 1x 10k Widerstand zuviel. Statt 100nF Kondensatoren wurden 1µF geliefert -> Platzprobleme auf der Platine durch grössere Bauform. LED grün.
* Bausatz Oktober 6 gekauft: alles funktioniert. LED grün statt rot.

* Fertigmodul Oktober 10 gekauft: Auf Anhieb alles funktioniert!
* Bausatz Oktober 10 gekauft: komplett und sofort funktioniert

* Bausatz November 10 gekauft: komplett und sofort funktioniert (sogar mit der neusten Pollin Firmware 1.03 schon drauf) LED grün statt rot.

* Bausatz November 10 gekauft. Nach Bezug neuer Feinst-Lötspitzen konnte ich ihn dann auch zusammenlöten. Es hat sofort alles funktioniert, obwohl ich nur 12V bzw. 9V Gleichspannung zur Verfügung hatte, und nicht sicher war, wieviel die Komponenten wirklich benötigen. Der Regler wird auch bei 9V Gleichspannungsversorgung noch sehr warm. Da muss auf jeden Fall ein Kühlkörper dran! Ich habe auch eine grüne LED bekommen, ist mir aber wurscht :-)

* Bausatz Dezember 10 gekauft: komplett und funktionierte sofort. Firmware 1.03, grüne LED (Ein Quarz und ein IC-Sockel zu viel)

*Bausatz Januar 2011 gekauft: nur genau die richtige Anzahl Teile dabei, Firmware 1.03, grüne LED, ging auf Anhieb

* 2x Bausatz Januar 2011 gekauft: beide grüne LED, und 1x doppelter Satz Jumper/Stiftleiste, 22PF und Anschlussklemmen. Rest vollständig und beide haben sofort nach zusammenbau funktioniert.

* Februar 2011: AVR-NET-IO: die Diode D5 fehlt, 10 µF gegen 1 µF für MAX232 getauscht, Flash im ATmega32 war programmiert, passende IP-Adr über serielle Schnittstelle eingestellt; ADD-ON: für R1 war 22Ω statt 0,2Ω beigelegt, durch richtigen ersetzt, Beschreibung der LED Bestückung mangelhaft / oe1smc

* Februar 2011: AVR-NET-IO: 1 Diode zuviel, 2 Spulen fehlen, LED grün. Die fehlenden Spulen wurden durch welche aus der Bastelkiste ersetzt - funktioniert. Der 7805 bekam einen kleinen Kühlkörper spendiert.

* Februar 2011: AVR-NET-IO: 2x 10k Widerstände fehlen. Dafür eine Diode zu viel.

* Ende Februar 2011: Zwei Bausaetze an jeweils zwei Adressen, alles in Ordnung.

* Ende März 2011: 2x 25 Mhz Quarz statt 1x16 u. 1x25 Mhz. LED fehlt. Bausatz funktioniert nach Tausch des Quarz den mir mein Freund oe9rsv aus seinem Fundus spendiert hat. Danke auch für die Hilfe beim Fehler suchen.

* Mitte 2010 gekauft: 1x 100nF fehlt

* Mitte Juni 2011: Beide Quarze fehlen und beide Spannungsregler fehlen, Pollin wollte, dass ich das ganze Paket zurückschicke für einen Austausch. Ein 51Ω zu viel. 16Mhz im Handel und 25Mhz vom alten Mobo ausgelötet. Läuft wunderbar.

* Anfang Juni 2011: Beide Quarze fehlen und beide Spannungsregler fehlen, nach kurzer Mail an Pollin (leider ohne Antwort) wurden diese nach ca. 1 Woche in einem Brief nachgeliefert.

* August 2011: alles 1a...
* August 2011: Platine fehlte -> in Nachlieferung
* 30 August 2011: alles 1a...
* 06 Sep. 2011: alles 1a...
* August 2011: 6 Stück bestellt, bei einem haben die 100nF Kondensatoren gefehlt, bei einem zwei LM317 statt 7805 und LM317. Angerufen, 3 Tage später Nachlieferung erhalten.
* Nov. 2011: '''Net_IO''' vollständig. Einspielen der Firmware 1.03 war erforderlich. Bei '''Add-On''' immer noch falscher Q1 BC548 (NPN) in Stückliste und Lieferung. BC327-40 oder BC328-40 (PNP) nachgefordert. R11 und R24 mitgeliefert entsprechend Beschreibung V1.1 von Pollin's Download. Beiliegende Beschreibung war älter, ohne diese Widerstände.

* Ende Nov.2011, alle Teile dabei, Firmware war drauf, sofort funktioniert.

* Anfang Dez.2011, komplett bestückte Platine gekauft. Auf 7805 Kühlkörper gebaut da er nach 1Minute schon ausgestiegen ist (LED hat das Pumpen angefangen). Firmware 1.03 musste noch aufgespielt werden danach funktioniert alles einwandfrei. In betrieb mit 10V DC
* Ende Dez.2011 2xNET-IO und 2xADD bestellt 4 verschieden volle Kisten bekommen... WSL16 ist mit verriegelung geht nicht aufs board jumper fehlen spannungsregler doppelt potti löcher zu klein lsb3 fehlt sd-slot hab ich jetzt 3 100nF hab ich jetzt 4 übrig ... also immnoch lustig HW stand immernoch 1.0 ( gab es überhaupt eine 1.1?)

* Mitte Jan. 2012, 10pol. beide Wannenstecker nicht dabei, Firmware war drauf, sofort funktioniert. 1 LED zuviel. Unproblematische Nachlieferung bei Reklamation (wegen der beiden Wannenstecker kam ein PAKET!).

== Andere Software für den Client-PC ==
=== NetIOLib ===

In C# geschriebene Bibliothek zur Ansteuerung der Platine im Orginalzustand. Inkl. Beispielsoftware und Quellcode (GNU GPL)

DLL: [http://www.tware.org/downloads/NetIOLib_dll.zip Download-Link]
Source: [http://www.tware.org/downloads/NetIOLib_src.zip Download-Link]

=== ControlIO ===
Einfache Bibliothek zur Ansteuerung mit Originalfirmware.
http://www.mikrocontroller.net/topic/149695

=== JAVA Lib ===
Einfache Java-Bibliothek zur Ansteuerung mit Originalfirmware.
http://son.ffdf-clan.de/?path=forumsthread&threadid=611

=== App NetIO ===
Frei verfügbare App für Windows Mobile zur Ansteuerung mit der Orginalsoftware. Das HTC HD2 wird damit zur Fernsteuerung für das AVR Net-IO Board.
http://www.heesch.net/netio.aspx

=== PHP ===
PHP Klasse zur Ansteuerung mit der Originalfirmware. (Opensource Lizenz)
http://blog.coldtobi.de/1_coldtobis_blog/archive/298_pollin_net-io_php_library.html

PHP Funktionen zum Ansteuern der Originalfirmware. (Free for All Lizenz)
http://defcon-cc.dyndns.org/projects/mikrocontroller/netio.php

=== NET-IO Control ===
Eine Application für das Android Betriebssystem zur Steuerung des AVR Net-IO Boards

[[Datei:NET-IO-Control.png|200px]] [[Datei:NET-IO-Control2.png|200px]] [[Datei:NET-IO-Control3.png|200px]]

Team: [http://elektronik2000.de/ E2000-Team]

=== iPhone ===
==== NetIO ====
[[Datei:NetIO_Screenshot1.png|160px|rechts]]

Schöne iPhone Fernbedienung für das Board. Konfigurierbar über eine JSON Datei. (Senden, Auslesen, Makros) 
AppStore Link: http://itunes.apple.com/app/netio/id464924297?mt=8 
Die gleiche Konfiguration kann auch mit einem [https://github.com/davideickhoff/NetIO-OSX-Dashboard-Widget OSX Widget] benutzt werden. 
Die inzwischen übersichtliche Webseite dazu findet man unter http://netio.davideickhoff.de

Hinweis: Man findet es unter "NetIO" im AppStore, im Icon selbst und in iTunes wird es als "Controller" angezeigt. 
Den JSON (JavaScriptObjectNotation) Code kann man im [http://jsonlint.com/ JSONLint Validator] prüfen. 
Die Grafikausgabe der "Buttons" kann man mit [http://netio.davideickhoff.de/renderjson NetIO JSON Renderer] vorher am PC überprüfen.

 

==== AVR Net IO ====
[[Datei:AVRNetIO-Screenshot1.png|160px|rechts]]
Update 15.12.2011: Die Neue Version 1.3 ist seit gestern im AppStore. Fehlerkorrekturen und ein robusteres Handling machen die App nun zur universellen AVR-Net-IO-Steuerung.

Mit der [http://itunes.apple.com/de/app/avr-net-io/id460991760?mt=8 iPhone App AVR-Net-IO] kann das Board ferngesteuert werden. Die Fernsteuerung umfasst in der Version 1.1 folgende Funktionen: <ul>
<li>ADC-Werte zyklisch auslesen und darstellen</li>
<li>Digital-Inputs zyklisch darstellen</li>
<li>Digital-Outputs können über Buttons geschaltet werden. Die Werte der Digital-Outputs werden zuerst ausgelesen und zeigen den zuletzt gesetzten Wert an.</li>
<li>Terminal-Modus: Hier können beliebige AVR-Net-IO-Befehle eingegeben werden. Das Ergebnis wird 1:1 angezeigt, wie es vom Board kommt. Hilfreich für Tests bei Eigenentwicklungen und Konfigurationen.</li>
</ul>
 
Mehr Infos gibt's dazu direkt von den Entwicklern auf [http://www.facebook.com/pages/AVR-Net-IO/187799687958255?ref=nf AVR-net-IO Facebook-Page] oder direkt auf deren Homepage [http://www.ondics.de/apps/1001/ Homepage].
 
Hinweis: MIt der aktuellen Version 1.1 gibt es noch bei manchen Boards Probleme beim auslesen und anzeigen der ADC- und Digital-Werte. Das Terminal funzt problemlos. Die Entwickler kümmern sich gerade drum und haben einen baldigen Update versprochen.
 

=== E2000 - Logik ===

[[Datei:E2000-Logik-Bedienoberflaeche.jpg|500px|rechts]]

Anwenderfreundliche Logik-Software vom Elektronik2000.de zur Steuerung des AVR-NET-IO über den Computer oder durch ein Firmware-Update auch autark.

'''Version 2.0a6''' beinhaltet eine Firmware, durch die das NET-IO mit einem Firmwareupdate in einen autarken Betrieb versetzt werden kann. Dazu ist ein ATMega644 notwendig. Durch diese Erweiterung ist es möglich, eine Logikschaltung in das Board zu schreiben, welche das Board dann simuliert. Es unterstützt außerdem ein Webinterface, eine TelNet-Schnittstelle und eine Live-View-Ansicht mit der es möglich ist, live zu sehen, wie der Status des Boards zu einem bestimmten Zeitpunkt ist. Die aktuelle Systemzeit wird aus dem Internet ermittelt.

Durch ein Erweiterungsboard von Elektronik2000.de ist es in '''Zukunft''' möglich, das Board ohne Internet laufen zu lassen durch eine RTC (RealTimeClock). Auf dieser Erweiterung wird auch ein EEPROM integriert sein, um Firmware-Updates über Netzwerk einzuspielen, damit kein direkter Eingriff in die Hardware notwendig ist. Diese Erweiterung bietet außerdem die Anbindung an das E2000-Bus-System.

Das Designen von Schaltaufgaben wird in diesem Programm grafisch dargestellt. Außerdem besitzt die Software (in der Version für die Pollin Firmware) einen Kennlinienschreiber und ein Webinterface.

Team: [http://www.elektronik2000.de E2000-Team]

== Andere Software statt der Originalsoftware von Pollin ==

Die Umrüstung auf einen Webserver durch Austausch der Software (und ev. des ATmega32) bietet sich an. Kleiner Hinweis dabei: wenn zum Flashen ein ISP-Adapter verwendet wird, diesen unbedingt vor dem Start der neuen Software abziehen! Der ISP arbeitet nämlich über dieselbe SPI-Schnittstelle über die auch der ENC28J60 angesteuert wird. Ein eventuell noch angeschlossener, wenn auch passiver ISP-Adapter stört diese Kommunikation, d.h. das Programm an sich scheint zu laufen, aber die Ethernet-Schnittstelle funktioniert nicht.

=== Bascom Version von Hütti ===

(Quelle: http://bascom-forum.de/index.php/topic,1781.45.html )
dort am Ende der Seite.

=== Ben's Bascom Quellcode ===

(Quelle: http://members.home.nl/bzijlstra/software/examples/enc28j60.htm )

Muss aber für Bascom 1.11.9.3 angepasst werden, siehe Code von Hütti !

=== U. Radigs Webserver ===

Angepasster Sourcecode von U.Radig: http://www.mikrocontroller.net/attachment/40027/Webserver_MEGA32.hex
oder selbst anpassen:
Ändere im File ENC28J60.H
#define ENC28J60_PIN_SS 3
#define ENC28J60_PIN_CS 4
(Quelle: http://www.mikrocontroller.net/topic/109988#988386)

Temporären Dateien (*.d, *,lst,*.o) vorher im Verzeichnis löschen ''make clean'', damit neu compiliert wird.

IP: 192.168.0.99 
User: admin 
Pass: uli1 

Den orginal SourceCode gibt's übrigens hier:http://www.ulrichradig.de/home/index.php/avr/eth_m32_ex

Bei den Fuses BOOTRST ausschalten, da die Software keinen Bootloader enthält.

Wer gerne als Link-LED die grüne nutzen möchte
(U.Radig-Source)

enc28j60.c Zeile 150

"enc28j60_write_phy(ENC28J60_PHY_PHLCON, 0x347A)

Wert 0x347A in 0x374A ändern

(Quelle: http://www.mikrocontroller.net/topic/109988#994943)

IP: 192.168.1.90 
User: admin 
Pass: tim 
Test: http://beitz-online.dyndns.org 
Test: http://pieper-online.dyndns.org 

Weiterentwicklung des Radig-Codes von RoBue: 
- 1-Wire-Unterstützung (Anschlus an PORTA7) 
- PORTA0-3 digitaler Eingang (ein/aus) 
- PORTA4-6 analoger Eingang (0 - 1023) 
- LCD an PORTC 
- Schalten in Abhängigkeit von Temperatur und analogem Wert 
- (Teilweise) Administration über Weboberfläche 
- Erweiterung des cmd-Befehlsatzes für telnet/rs232 
Gedacht ist der Einsatz des AVR-NET-IO-Bausatzes für Heizungs- oder Haussteuerung) 

Test: http://avrboard.eluhost.de/ 

(Quelle: 
http://www.mikrocontroller.net/attachment/43307/AVR-NET-IO_RoBue_V1.3.zip 
http://www.mikrocontroller.net/attachment/44569/AVR-NET-IO_RoBue_V1.4.zip 
http://www.mikrocontroller.net/attachment/46720/AVR-NET-IO_RoBue_1.5-final_hoffentlich_.zip)

Bei der Ver 1.5 sind die Ports PD2+3 fürs 4bit LCD (Ext.) vertauscht ! Gruß B.P

=== Simon Ks Webserver (uip-Stack) ===
Angepasster Sourcecode von Simon K: http://www.mikrocontroller.net/attachment/39939/uWebSrv.zip
IP: 192.168.0.93:8080 
Um diesen Code mit einem Atmega1284P verwenden zu können, muss in der main.c in Zeile 38, "TIMSK" durch "TIMSK1" ersetzt werden.
Die Fusebits für den Atmega1284p ohne Bootloader sind:
lfuse=0xFF, hfuse=0xD9, efuse=0xFF

=== Ethersex Server ===

http://www.ethersex.de - Einfach für atmega32 compilieren und funktioniert.

Oder
[http://www.ethersex.de/firmware-builder/list.cgi hier] ein Firmware Image passend für das Pollin Net-IO mit eingebautem Webserver und Beispieldateien im Flash bauen lassen und flashen (firmware-builder). Einfacher geht´s nimmer. :-)

=== Etherrape Server ===

http://www.lochraster.org/etherrape/

ist in jedem Fall hier auch zu erwähnen zumal es sich beim etherrape um das Ursprungsprojekt von ethersex handelt.
Es scheint aber bei der Weiterentwicklung wenig zu passieren.
Ausführliche Dokumentation findet sich unter http://wiki.lochraster.org/wiki/Etherrape

=== Mini SRCP Server (kommerziell, Closed-Source)===

Damit wird die Platine zu einer Modellbahnsteuerung, die
über das Netzwerkprotokoll SRCP mit verschiedenen Programmen
gesteuert werden kann.

[http://www.7soft.de/de/mini_srcp_server/index.html Infoseite] zur Hardware
und das zugrundeliegende [http://www.der-moba.de/index.php/Digitalprojekt Digitalprojekt].

=== AvrArtNode ===

Hiermit kann die Platine zu einem Art-Net Node werden, mit dem sich ein DMX-Universe über Ethernet übertragen lässt. Basiert auf den Quellen von Ulrich Radig.

Dokumentation: [http://www.dmxcontrol.de/wiki/Art-Net-Node_f%C3%BCr_25_Euro Art-Net-Node für 25 Euro]

=== Webserver von G. Menke ===

Ein Webserver (basierend auf den Sourcen von U. Radig), der so angepasst ist, dass alle Ein- und Ausgänge wie bei der originalen Pollin-Software genutzt werden können (8xDIGOUT, 4xDIGIN, 4xADIN). Der Webserver kann daher direkt auf das Net-IO geladen werden. Im ZIP-File sind ein ReadMe und alle C-Sourcen enthalten. Download:
[http://gm.stream-center.de/webserver/ Webserver mit passender IO]

=== OpenMCP ===

Tolles Projekt, welches viele Features bietet und stabil läuft. Hervorzuheben ist die Übersichtlichkeit der Programmteile/Module und die vielleicht nicht ganz komplette Dokumentation. Man merkt das viel Arbeit und Liebe in diesen Projekt steckt. Herausgekommen ist dabei eine einfach zu handhabende Entwicklungsumgebung. Anfänger können, dank des gut durchdachten CGI-System welches sich um alle wichtigen Sachen kümmert, leicht eigene CGI implementieren. Alle Ausgaben erfolgen nur mit printf über die Standardausgabe und werden automatisch richtig per Netzwerk übertragen, dadurch ist es auch für den Anfänger recht gut geeignet, da man sich nicht mit der Netzwerkprogrammierung auseinander setzen muss.

Die Software belegt im Moment (Stand Juli 2010) ca. 55 Kb im Flash, so dass man das Board mit einem grösseren µC (z.B. ATMega644) aufrüsten muss.

[http://wiki.neo-guerillaz.de Projekt und Doku]

Der Autor stellt zwei über das Internet erreichbare Testboards bereit unter http://www.neo-guerillaz.de:81 und http://www.neo-guerillaz.de:82 die beide unter OpenMCP laufen, je auf einen AVR-NETIO mit einem ATmega644 und dem eigentlichen Board mit einem ATmega2561. Zusätzlich ist gerade eine Version für das myAVR in Arbeit die schon ordentlich Fortschritte macht.

=== ENC28J60 I/O-Webserver von Thomas Heldt ===

Ein Modul-Webserver (Softwarekompatibel zum Pollin Webserver), der durch div. Module erweitert werden kann, Software in Bascom basierend auf dem Code von Ben Zijlsta wurde erweitert und angepasst:

[http://mikrocontroller.heldt.eu/index.php?page=enc28j60-io-webserver Projekt und Software]

== Siehe auch ==
* Diskussion zu diesem Projekt: http://www.mikrocontroller.net/topic/109988
* [http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en022889 ENC28J60 Produktseite]
* [http://ww1.microchip.com/downloads/en/DeviceDoc/39662c.pdf ENC28J60 Datenblatt(pdf)]
* [http://son.ffdf-clan.de Forum für AVR-Net-IO]
* [http://bascom-forum.de/index.php/topic,1781.0.html Bascom Forum ]
* [http://hobbyelektronik.org/w/index.php/AVR-NET-IO-Shield Shield für den NET-IO]

[[Category:AVR-Boards]]
[[Category:Ethernet|P]]

Operationsverstärker-Grundschaltungen

2011-12-13T09:01:16Z

145.225.60.4: /* Spannungsfolger (Impedanzwandler) */

== Idealisiertes Modell eines OPV ==

=== Anschlüsse ===
Ein Operationsverstärker hat zwei Eingänge (+) und (-) und einen Ausgang
(UA). Außerdem verfügt er über eine positive und eine negative
Spannungsversorgung (V+) und (V-).

=== Spannungsversorgungen ===
Die Spannungsversorgungen sollen zunächst nicht interessieren. Sie
werden in Schaltungen oft nicht eingezeichnet.
In der Praxis ist es jedoch wichtig zu wissen, dass die Ausgangsspannung immer zwischen (V+) und (V-) liegt. Die Ausgangsspannung des OPV kommt schließlich dadurch zustande, dass der Ausgang über einen Transistor mehr oder weniger hochohmig mit den beiden Versorgungsspannungen verbunden wird.

Wenn man einen OPV also mit +5V versorgt, so kann der OPV im besten Fall am Ausgang +5V erzeugen. Man würde in diesem Fall von einem "Rail-to-Rail" Operationsverstärker sprechen.
Bei vielen Operationsverstärkern ist die maximal mögliche Ausgangsspannung geringer als die Versorgungsspannung. Ein mit +5V Spannungsversorgung beschalteter OPV kann dann beispielsweise nur +4V Ausgangsspannung erzeugen.

| \
| \
-- | - \
| \_______
| /
-- | + /
| /
| /

=== Ausgang ===
Der Ausgang des OPV ist eine ideale Spannungsquelle. Das bedeutet, dass die
Ausgangsspannung unabhängig davon ist, was ausgangsseitig an den OPV
angeschlossen wird.
In der Praxis gilt dieses Modell häufig nur bei "sinnvollen Anwendungen". So ist beispielsweise der Ausgangsstrom des OPV nach oben begrenzt (typischerweise im mA-Bereich), und manche OPV schwingen sehr leicht, wenn man sie kapazitiv belastet.

=== Eingänge ===
Die Eingänge eines OPV sind hochohmig, d. h., es handelt sich nur um "Messfühler", die keinen Strom führen.

=== Funktionsweise ===
Der OPV mißt zu jeder Zeit die Differenz <math>U_D = U(+) - U(-)</math> der
Eingangsspannungen.

Ist die Spannung an (+) größer als an (-), so erhöht der OPV die
Ausgangsspannung.
Ist die Spannung an (+) niedriger als an (-), so vermindert der OPV die
Ausgangsspannung.

Das Ergebnis dieses Vorgangs wird häufig über die Gleichung:

<math>U_a = v \cdot U_D</math>

beschrieben, wobei <math>v</math> eine sehr große Zahl (10^4...10^6) ist.

Mit Hilfe der beschriebenen Funktionsweise lassen sich alle grundlegenden Schaltungen herleiten.

=== Beispiel ===

Betrachtet wird die invertierende Grundschaltung nach Abbildung a) im Abschnitt "Verstärkergrundschaltungen".

Für die Pfeilrichtungen der Spannungen und Ströme gilt:

<math>U_e</math>: von oben nach unten

<math>I_{R3}</math>: von links nach rechts

Die Spannung am (+)Eingang ist gleich Null. Die Spannung am (-)Eingang wird durch die Spannungsquelle <math>U_e</math> und durch die im OPV befindliche und mit dem Ausgang verbundene Spannungsquelle des OPV manipuliert.

* Ist die Spannung am (-)Eingang negativ, so erhöht der Operationsverstärker die Ausgangsspannung. Dadurch wird auch die Spannung am (-)Eingang positiver. Und zwar so lange, bis die Spannung am (-)Eingang gleich groß ist, wie die Spannung am (+)Eingang, also U(-)=0V.
* Ist die Spannung am (-)Eingang positiv, so vermindert der Operationsverstärker die Ausgangsspannung. Dadurch wird auch die Spannung am (-)Eingang negativer. Und zwar so lange, bis die Spannung am (-)Eingang gleich groß ist, wie die Spannung am (+)Eingang, also U(-)=0V.

Der Operationsverstärker wird also die Spannungen an (+) und (-)
angleichen. Das passiert immer dann, wenn der Ausgang mit dem (-)Eingang
verbunden ist. Man nennt das Prinzip "Gegenkopplung". Auf diese Art und
Weise funktionieren alle analogen OPV-Schaltungen.

Da an (+) Massepotential anliegt, liegt an <math>R_3</math> die Spannung <math>U_e</math> an, und es gilt:
<math>I_{R3}=\frac{U_e}{R_3}.</math>

Da der (-)Eingang hochohmig ist, fließt <math>I_{R3}</math> über <math>R_4</math> weiter zum OPV-Ausgang.

Ua ist die Spannung vom Ausgang zur (virtuellen) Masse am (-)Eingang.
(--> Pfeil einzeichnen und klarmachen, daß es egal ist, ob der Pfeil vom
Ausgang zur Masse geht oder vom Ausgang "entgegen der Stromrichtung" zur
virtuellen Masse an (-)!)

Mit Hilfe von <math>I_{R3}=\frac{U_e}{R_3}</math> ergibt sich:

<math>U_a = -R_4 \cdot I_{R3} = -{{R_4} \over {R_3}} \cdot U_e.</math>

Die Energie für den Stromtransport über <math>R_4</math> stammt vom OPV! Sobald die Ladungen ausgehend von der Spannungsquelle <math>U_e</math> die virtuelle Masse an (-) erreicht haben, hat <math>U_e</math> seine gesamte Energie abgegeben.

== Reale OPs / Kennwerte ==
Abweichend vom idealen OP besitzen reale OPs diverse Einschränkungen und Kennwerte, die sie für verschiedene Einsätze mehr oder weniger prädestinieren.

=== Leerlaufverstärkung ===
Die Leerlaufverstärkung gibt an, wie stark sich das Ausgangssignal i.A. der Änderung eines Eingangsignals statisch ändert, bzw nach dem Einschwingen erreichen könnte, wenn es nicht durch die Betriebsgrenzen limitiert wäre.

=== Anstiegszeit ===
Bestimmend für die dynamische Änderung des Signal ist wiederum die slew rate, die wesentlich das AC-Verhalten bestimmt.

=== Frequenz-Bandbreiteprodukt ===

=== Gleichtaktverstärkung ===
Infolge des inhomogenen Aufbaus der internen Verstärkerstufen werden die beiden Eingangssignale nicht exakt gleich verstärkt, was in einen Gleichanteil und einen Differenzaneil aufgeteilt werden kann. Der nicht erwünschte common mode ist dabei ein Mass für die Qualität des OP.

== Verstärkergrundschaltungen ==
=== Grundbeschaltung mit Berechung ===
[[Bild:Op-verstaerker-a.png]] [[Bild:Op-verstaerker-b.png]]

In a) und b) verwenden wir den OP als Verstärker und nutzen hier die Möglichkeit der Gegenkopplung, um definierte Verstärkungen zu erhalten. Wir gehen wieder davon aus, dass der OP ein ideales Bauteil ist und daher seine Leerlaufverstärkung unendlich ist. Ebenso betrachten wir den Eingangswiderstand als unendlich.

In a) ist ein invertierender Verstärker mit einem OP dargestellt. Durch die Widerstände R3 und R4 wird die Verstärkung bestimmt:

:<math>V = \frac{U_a}{U_e} = -\frac{R_4}{R_3}</math>

Das Verhältnis der beiden Widerstände bestimmt also die Verstärkung und somit die Ausgangsspannung:

:<math>U_a = -\frac{R_4}{R_3} \cdot U_e </math>

oder auch

:<math>U_a = V \cdot U_e</math>

Das negative Vorzeichen drückt aus, dass es sich um einen invertierenden Verstärker handelt.

Beim nichtinvertierenden Verstärker b) finden wir auch eine Rückkopplung über R6 zum invertierenden Eingang des OP. Die Verstärkung wird durch das Gegenkopplungsnetzwerk R6 und R7 exakt definiert. Hier ist:

:<math>V = 1 + \frac{R6}{R7}</math>

Eine Verstärkung von 1 ist sinnvoll, wenn eingangsseitig eine Spannungsquelle mit hohem Innenwiderstand verwendet wird. Für <math>\frac{R6}{R7} \to 0</math> heißt die Schaltung "Spannungsfolger".

Kleinere Werte als 1 lassen sich nicht realisieren. Die Ausgangsspannung errechnet sich also so:

:<math>U_a = U_e \cdot \left (1 + \frac{R_6}{R_7}\right )</math>

Beispiel: Eine Eingangsspannung von 0,5 V soll auf den Wert 5 V verstärkt werden, es ist also eine Verstärkung V von 10 benötigt. R7 ist mit 10 kΩ vorgegeben. Also ist das Verhältnis

:<math>\frac{R_6}{R_7} = V - 1</math>

Bei einem Wert von 10 kΩ für R7 errechnet sich R6 zu

:<math>
R6 = (V - 1) \cdot R7
= (10 - 1) \cdot 10\,\mathrm{k\Omega}
= 90\,\mathrm{k\Omega}
</math>

Die Ausgangsspannung Ua wird also:

:<math>
U_a = U_e \cdot \left (1 + \frac{R_6}{R_7}\right )
= 0,5\,\mathrm{V} \cdot \left (1 + \frac{90\,\mathrm{k\Omega}}{10\,\mathrm{k\Omega}}\right)
= 5\,\mathrm{V}
</math>

=== Spannungsfolger (Impedanzwandler) ===

[[Bild:Op-spannungsfolger1.png]]

Eine Abart des nichtinvertierenden Verstärkers stellt der Spannungsfolger dar. Beim nichtinvertierenden Verstärker errechnet sich die Ausgangsspannung aus:

:<math>U_a = U_e \cdot \left (1 + \frac{R_2}{R_1}\right )</math>

Wenn wir R2 auf 0Ω (mit R1 > 0) oder R1 auf unendlich (mit R2 < ∞) ändern, erhalten wir daher:

:<math>V = 1 + \frac{R_2}{R_1} = 1</math>

Ein Spannungsfolger hat also eine Verstärkung V von 1.

Umgezeichnet sieht die Schaltung so aus:

[[Bild:Op-spannungsfolger2.png]]

Was soll das nun? Wir nutzen die Eigenschaft, dass ein idealer OP einen unendlichen Eingangswiderstand und einen Ausgangswiderstand von 0Ω hat. Real sieht das natürlich anders aus: so liegt der Eingangswiderstand Re bei normalen OPs in der Größenordnung von 1MOhm bis <math>10^{15} \Omega</math>, der Ausgangswiderstand Ra im Bereich 20Ω bis 1kOhm. Deshalb spricht man bei dieser Schaltung von einem Impedanzwandler. Eine solche Schaltung kann also aus einer relativ hochohmigen Spannungsquelle eine niederohmige, durch Folgeschaltungen belastbare Spannungsquelle machen.

[[Bild:Op-spannungsfolger3.png|left]]

In dem nebenstehenden Beispiel ist eine einfache Möglichkeit zur Erzeugung einer Referenzspannung gezeigt. Es kommt eine normale Stabilisierungsschaltung mit einer Zenerdiode zur Anwendung, die aber nicht mehr die schlechten Eigenschaften der Standardbeschaltung mit lediglich Widerstand und Zenerdiode hat. Bei einer Zenerdiode hängt die genaue Spannung davon ab, welcher Strom durch sie durchfliesst. Dieser Strom (und damit auch die Höhe der Zenerspannung) würde sich aber ändern, wenn ein Verbraucher die Zenerdiode direkt mit seinem Stromfluss belasten würde. Als Folge davon würde die Spannungslage der Zenerdiode je nach Verbraucher leicht schwanken. Durch den Spannungsfolger wird das verhindert, weil der jetzt den vom Verbraucher gezogenen Strom bereitstellt.

{{Clear}}

[[Bild:Op-spannungsfolger4.png|left]]

Eine weitere Anwendungsmöglichkeit wäre das hochohmige Auskoppeln einer Brückenspannung. Die Brückenschaltung selbst wird durch Folgeschaltungen nicht mehr belastet, alle anderen Eigenschaften bleiben erhalten.

{{Clear}}

=== Der Komparator ===

[[Bild:Op-komp-a.png]] [[Bild:Op-komp-b.png]]

In der einfachsten Beschaltung des Operationsverstärkers erhält man einen Komparator. Es fällt auf, dass kein Gegenkopplungsnetzwerk vorhanden ist. Der OP arbeitet daher mit seiner vollen Leerlaufverstärkung Vo. Dies bedeutet, dass bereits eine kleine Eingangsspannung genügt, um den OP in die Begrenzung zu treiben. Das heißt, die Ausgangsspannung Ua wird annähernd die Betriebsspannung erreichen.

Beim Komparator gibt es zwei Möglichkeiten der Beschaltung: die invertierende nach a) und die nichtinvertierende Beschaltung nach b).

==== Berechnungsbeispiel für Schaltung b) ====

Angenommen die Leerlaufverstärkung Vo von 40000 und eine Eingangsspannung von 0,1 Volt. Die Betriebsspannungen Vcc und Vee legen wir auf +/- 24 V fest. Damit ergibt sich theoretisch für Ua:

:<math>U_a = V_0 \cdot U_e = 40000 \cdot 0,1\,\mathrm{V} = 4000\,\mathrm{V}</math>

Das ist natürlich ein unrealistischer Wert, da Ua nicht höher sein kann als die Betriebsspannung. Also anders ausgedrückt: Bei welcher Spannung Ue erreicht der OP seine Aussteuerungsgrenze?

:<math>U_e = V_{cc} / V_0 = 24\,\mathrm{V} / 40000 = 0,6\,\mathrm{mV}</math>

Das bedeutet, dass eine Spannung von 0,6 mV ausreicht um den Komparator in die Begrenzung zu treiben.

Das gleiche gilt auch für den invertierenden Komparator, allerdings wird hier der OP in die negative Begrenzung gebracht.

:<math>-U_a = V_0 \cdot U_e</math>

=== Der Addierer (Summierverstärker) ===

[[Bild:Op-addierer.png]]

Ein als invertierender Verstärker beschalteter OP lässt sich so beschalten, dass ein Summensignal aus den Eingangsspannungen gebildet wird. Um die Funktion deutlich zu machen, ist eine Betrachtung der einzelnen Ströme nötig.

In einem invertierenden Verstärker wird sich die Ausgangsspannung immer so einstellen, dass der invertierende Eingang Massepotential hat. Die virtuelle Masse (VM) unterscheidet sich von einer "normalen" Masse dadurch, dass das Potential durch einen Regelungsvorgang zustande kommt.
An der virtuellen Masse (VM) gilt die Knotenpunktregel, wonach die Summe der zufließenden Ströme gleich der Summe der abfließenden Ströme ist.

:<math>I_1 + I_2 = -I_3</math>

Sofern <math>U_{e1}</math> und <math>U_{e2}</math> bekannt sind, lässt sich die Gleichung umformen in:

:<math>\frac{U_{e1}}{R_1} + \frac{U_{e2}}{R_2} = -\frac{U_a}{R_3}</math>

Nach Ua aufgelöst ergibt sich:

:<math>-U_a = \left (U_{e1} \cdot \frac{R_3}{R_1}\right ) + \left (U_{e2} \cdot \frac{R_3}{R_2}\right ) + ... + \left (U_{en} \cdot \frac{R_3}{R_n}\right )</math>

Das war's eigentlich schon. Einen Sonderfall gibt es, wenn die Widerstände R1 und R2 gleich sind. Dann gilt

:<math>R_1 = R_2 = R_x</math>

und damit

:<math>-U_a = \frac{R_3}{R_x} \cdot (U_{e1} + U_{e2})</math>.

=== Der Subtrahierer (Differenzverstärker) ===

[[Bild:Op-subtrahierer.png]]

Ein Subtrahierer ist die Zusammenschaltung eines invertierenden und eines nichtinvertierenden Verstärkers. Schliessen wir Punkt Ue1 nach Masse kurz und steuern Ue2 an, arbeitet die Schaltung als nichtinvertierender Verstärker. Wird Ue2 nach Masse verbunden und Ue1 angesteuert, verhält sich die Schaltung als invertierender Verstärker (R7 vorerst nicht beachten).

Für den 1. Fall gilt:

:<math>U_a = U_{e2} \cdot \left (1 + \frac{R_6}{R_4}\right )</math>

Für den 2. Fall:

:<math>U_a = -U_{e1} \cdot \frac{R_6}{R_4}</math>

Der dritte Fall ist die Ansteuerung beider Eingänge:

:<math>U_a = -U_{e1} \cdot \frac{R_6}{R_4} + U_{e_2} \cdot \left (1 + \frac{R_6}{R_4}\right )</math>

Diese Schaltung ist gut für eine Erklärung, praktisch aber taugt sie nichts. Denn liegen an den Eingängen gleiche Spannungen an, ist die Ausgangsspannung nicht 0, wie eigentlich zu vermuten wäre. Deshalb ändern wir die Schaltung und fügen R7 ein. Jetzt stellt sich am Punkt + des OPs die Spannung

:<math>U_{e2+} = U_{e2} \cdot \frac{R_7}{R_5 + R_7}</math>

ein. Wenn wir das berücksichtigen, erhalten wir endlich einen richtigen Subtrahierer:

:<math>U_a = U_{e2} \cdot \left (1 + \frac{R_6}{R_4}\right ) \cdot \frac{R_7}{R_5 + R_7} - \frac{R_6}{R_4} \cdot U_{e1}</math>

Dies gilt für alle Subtrahierer, obwohl es natürlich auch hier wieder zwei Sonderfälle gibt; nämlich a) wenn alle Gegenkopplungswiderstände gleich sind:

:<math>R_6 = R_7 = R_4 = R_5</math>

dann ist

:<math>U_a = U_{e2} - U_{e1}</math>

oder b) wenn die Widerstandsverhältnisse gleich sind :

:<math>\frac{R_6}{R_4} = \frac{R_7}{R_5}</math>

Dann ergibt sich für Ua:

:<math>U_a = \left (U_{e2} \cdot \frac{R_6}{R_4}\right ) - \left (U_{e1} \cdot \frac{R_6}{R_4}\right )</math>

oder noch einfacher:

:<math>U_a = (U_{e2} - U_{e1}) \cdot \frac{R_6}{R_4}</math>

=== Addierer/Subtrahierer mit unterschiedlichen Faktoren ===
Legt man nicht den + sondern den - Eingang des Operationsverstärkers als Bezugspunkt zur Masse mit einem Widerstand fest, übernimmt der Vorwiderstand vom - Eingang, R4 die Aufgabe von R5.

[[Bild:Op-addsub.png]]

Hier die Schaltung die addieren und subtrahieren kann, mit unterschiedlichen Faktoren.
Sie kann verwendet werden für Aufgaben wie: Gesucht ist eine Schaltung, die aus 0...2.56 V eine Spannung von -10V...10V macht. Für dieses Beispiel wird hier die Dimensionierung durchgeführt:

{| class="wikitable" style="text-align: left"
|'''Ue1 = 5V'''
|Einfach festgelegt, muss nur ein positiver Wert sein
|-
|'''R6 = 200k'''
|Einfach festgelegt, könnte auch 100k oder 500k sein
|-
|Ue2i = 0V, '''Uai = -10V'''
|gewählter momentaner ''Zustand 1'', Ue2 = 0V ist günstig für Berechnung, Ua ist die dazupassende Ausgangsspannung
|-
|'''Ue2ii = 2.56V''', '''Uaii = 10V'''
|gewählter beliebiger ''Zustand 2''
|-
|Um = Ue2
|Gleichgewicht am Eingang
|-
|Ia + Ib = Ic
|In den Eingang fließt "kein" Strom
|-
|(Ua-Ue2)/R6 + (Ue1-Ue2)/R4 = Ue2/Rc
|Gleichung mit den Unbekannten R4 und Rc
|-
|(Uai-Ue2i)/R6 + (Ue1-Ue2i)/R4 = Ue2i/Rc
|Variablen für ''Zustand 1'' eingesetzt, bildet 1. Gleichung
|-
|(Uaii-Ue2ii)/R6 + (Ue1-Ue2ii)/R4 = Ue2ii/Rc
|Variablen für ''Zustand 2'' eingesetzt, bildet 2. Gleichung
|-
|<math>R4=-\frac{R6*U_{e1}}{U_{ai}}</math>
|2 Gleichungen mit 2 Unbekannten, Lösung durch Umformen der 1. Gleichung nach R4 und einsetzen von Ue2i=0 (freundlicherweise fällt die 2. Unbekannte dabei raus)
|-
|'''R4 = 100k'''
|restliche Werte eingesetzt
|-
|<math>Rc=\frac{R6*U_{e1}*U_{e2ii}}{U_{aii}*U_{e1}-U_{ai}*(U_{e1}-U_{e2ii})-U_{e1}*U_{e2ii}}</math>
|Ergebnis für R4 in die 2. Gleichung einsetzen und Umformen nach Rc
|-
|'''Rc = 41.6k'''
|Werte eingesetzt
|}

=== Der Instrumenten-Verstärker ===

[[Bild:Instrument.png]]

Ein Nachteil des Subtrahierer ist sein geringer Eingangswiderstand. Um den nahezu unendlichen Eingangswiderstand des verwendeten Operationsverstärkers zu erreichen, kann man einfach vor beide Eingänge je einen Impedanzwandler vorschalten.
Die hier beschriebene Schaltung ist um drei Widerstände erweitert und ermöglicht die Einstellung der Differenz-Verstärkung über nur einen Widerstand, nämlich R2.

Am invertierenden Eingang von IC1A gilt (Knotenregel):

:<math>\frac{U_{a1}-U_{e1}}{R_1}-\frac{U_{e1}-U_{e2}}{R_2}=0</math>

Am invertierenden Eingang von IC1C gilt (Knotenregel):

:<math>\frac{U_{a2}-U_{e2}}{R_1}+\frac{U_{e1}-U_{e2}}{R_2}=0</math>

Subtrahiert man die beiden Gleichungen voneinander, erhält man:

:<math>U_{a2}-U_{a1}=(U_{e2}-U_{e1})\cdot\left (1+\frac{2\cdot R_1}{R_2}\right )</math>

Letztere Differenz ist die Eingangsspannung eines normalen Subtrahierers mit der Verstärkung 1.

Also ergibt sich als Ausgangsspannung:

:<math>U_a=(U_{e2}-U_{e1}) \cdot \left (1+\frac{2\cdot R_1}{R_2}\right )</math>

Die Differenzverstärkung beträgt demnach:

:<math>V=\left (1+\frac{2\cdot R_1}{R_2} \right )</math>

Anwendung: Auswertung von Brückenschaltungen, wie Drucksensoren oder Dehnungsmessstreifen, die durch den Eingangswiderstand der Messschaltung nicht belastet werden dürfen. 
Instrumenten-Verstärker kann man auch fertig kaufen. Im INA102 ist die komplette Schaltung integriert. Für R2 sind 3 verschiedene Werte eingebaut, die bei passender Verschaltung eine Verstärkung von 1, 10, 100 oder 1000 ermöglichen.

=== Der Multiplizierer (Mischer) ===

=== Der Logarithmierer ===

= Spannungsversorgung und Beschaltung =

== Betrieb mit einfacher Versorgungsspannung ==

Häufig möchte man Wechselspannung (z. B. Audiosignale) die auch negative Spannungen enthält mit einem Opamp verstärken, hat aber nur eine einfache Versorgungsspannung, eine positive in Bezug zu Masse, zur Verfügung. Dafür bieten sich folgende Schaltungen an, die in der Literatur leider häufig vernachlässigt werden.

=== Nichtinvertierender Verstärker ===

[[Bild: Ss_opamp1.png]]

Der negative Eingang wird mit einem Spannungsteiler auf die halbe Betriebsspannung gelegt und das Signal mit Kondensatoren am Ein- und Ausgang entkoppelt.
Die Verstärkung ist in diesem Beispiel für Wechselspannung 11 (Formel wie oben), für Gleichspannung aber 1, da C4 für Gleichspannung einen unendlichen Widerstand darstellt. C3 sollte dorthin gehen, wo das Eingangssignal seinen Bezugspunkt hat, also die Abschirmung der Cinch-Buchse, während R5 dorthin geht, wo der Operationsverstärker seine negative Versorgungsspannung her bekommt, falls das nicht die gleichen Potentiale, hier GND, sein sollten.

=== Invertierender Verstärker ===

Das Prinzip funktioniert analog auch für die invertierende Beschaltung:

[[Bild: Ss_opamp2.png]]

= Kaufempfehlung =
LM 158/258/358 2 OPs in einem Gehäuse Preis ca. 0,30€.

Siehe auch [[Standardbauelemente#Operationsverst.C3.A4rker|Standardbauelemente - Operationsverstärker]].

Wer Audio OpAmps sucht - tangentsoft.net hat mal welche unter die Lupe genommen: [http://www.tangentsoft.net/audio/opamps.html Notes on Audio OpAmps]

= Weblinks =
*[http://www.eetkorea.com/ARTICLES/2003SEP/A/2003SEP19_AMD_AN07.PDF Op Amp Circuit Collection] - National Semiconductor Application Note 31 mit vielen weiteren OP-Schaltungen
*[http://www-s.ti.com/sc/psheets/slod006b/slod006b.pdf Op Amps for Everyone] - englischsprachiges, sehr umfangreiches Dokument zu OPV und deren Anwendung (empfehlenswert)
* [http://www.elektronik-kompendium.de/sites/bau/0209092.htm Operationsverstärker im ElKo]
*[http://www.inf.fu-berlin.de/lehre/WS00/peg/folien/Peg_v7a.pdf OP Teil 1], [http://www.inf.fu-berlin.de/lehre/WS00/peg/folien/Peg_v7b.pdf OP Teil 2] - OP-Schaltungen (deutsch)
*[http://www.blecken.de/download/opverst.zip Schaltungstechnik mit Operationsverstärkern] - Prof. K. Blecken, Skript zur Vorlesung (deutsch, *.doc-Format)
* [http://www.roboternetz.de/wissen/index.php/Operationsverst%C3%A4rker RN-Wissen Operationsverstärker]
* [http://www.national.com/onlineseminar/#amps Online Seminar] von National Semiconductor
* [http://www.franzis.de/elo-das-magazin/grundlagen-und-ausbildung/operationsverstaerker/der-operationsverstaerker ELO-Online-Magazin, Franzis-Verlag], [http://www.franzis.de/online-shop/elektronik/lernpakete-elektronik/lernpaket-elektronik-mit-ics Lernpaket Elektronik mit ICs] "Elektronische Experimente mit integriertem Schaltkreis", Kasten mit Steckbrett/Bauelementen (ca. 40EUR),
* [[Schmitt-Trigger]]
* [[Aktiver RC-Bandpass|Aktiver RC-Bandpass auf Operationsverstärker-Basis]]

[[Category:Grundlagen]]
[[Category:Bauteile]]

AVR-GCC-Tutorial/Der UART

2011-12-05T12:48:03Z

145.225.60.4: /* Softwarehandshake (XON/XOFF) */

Über den [[UART]] kann ein [[AVR]] leicht mit einer [[RS-232]]-Schnittstelle eines PC oder sonstiger Geräte mit "[[seriell]]er Schnittstelle" verbunden werden.

== Allgemeines zum UART ==

Mögliche Anwendungen des UART:

;Debug-Schnittstelle: z. B. zur Anzeige von Zwischenergebnissen ("printf-debugging" - hier besser "Logging" oder "UART-debugging") über [[RS-232]] auf einem PC. Auf dem Rechner reicht dazu ein [[RS-232#Terminalprogramme|Terminalprogramm]] (MS-Windows: Hyperterm oder besser [https://sites.google.com/site/terminalbpp/], [http://www.der-hammer.info/terminal/ HTerm]; Unix/Linux z. B. minicom). Ein direkter Anschluss ist aufgrund unterschiedlicher Pegel nicht möglich, jedoch sind entsprechende Schnittstellen-ICs wie z. B. ein MAX232 günstig und leicht zu integrieren. Rechner ohne serielle Schnittstelle können über fertige USB-seriell-Adapter angeschlossen werden.
;Mensch-Maschine Schnittstelle: z. B. Konfiguration und Statusabfrage über eine "Kommandozeile" oder Menüs (siehe z. B. Forumsbeitrag [http://www.mikrocontroller.net/topic/52985 Auswertung RS232-Befehle] und Artikel [[Tinykon]])
;Übertragen von gespeicherten Werten: z. B. bei einem Datenlogger
;Anschluss von Geräten: mit serieller Schnittstelle (z. B. (Funk-)Modems, Mobiltelefone, Drucker, Sensoren, "intelligente" LC-Displays, GPS-Empfänger).
;"Feldbusse": auf RS485/RS422-Basis mittels entsprechenden Bustreiberbausteinen (z. B. MAX485)
;DMX, Midi: etc.
;LIN-Bus: '''L'''ocal '''I'''nterconnect '''N'''etwork: Preiswerte Sensoren/Aktoren in der Automobiltechnik und darüber hinaus

Einige AVR-Controller haben ein bis zwei vollduplexfähige UART ('''U'''niversal '''A'''synchronous '''R'''eceiver and '''T'''ransmitter) schon eingebaut ("Hardware-UART").
Übrigens: Vollduplex heißt nichts anderes, als dass der Baustein gleichzeitig senden und empfangen kann.

Neuere AVRs (ATmega, ATtiny) verfügen über einen bis vier U'''S'''ART(s), dieser unterscheidet sich vom UART hauptsächlich durch interne FIFO-Puffer für Ein- und Ausgabe und erweiterte Konfigurationsmöglichkeiten. Die Puffergröße ist allerdings nur 1 Byte.

== Die Hardware ==

Der UART basiert auf normalem TTL-Pegel mit 0V (logisch 0) und 5V (logisch 1). Die Schnittstellenspezifikation für RS-232 definiert jedoch -3V ... -12V (logisch 1) und
+3 ... +12V (logisch 0). Daher muss der Signalaustausch zwischen AVR und Partnergerät invertiert werden. Für die Anpassung der Pegel und das Invertieren der Signale gibt es fertige Schnittstellenbausteine. Der bekannteste davon ist wohl der MAX232.


Streikt die Kommunikation per UART, so ist oft eine fehlerhafte Einstellung der Baudrate die Ursache. Die Konfiguration auf eine bestimmte Baudrate ist abhängig von der Taktfrequenz des Controllers. Gerade bei neu aufgebauten Schaltungen (bzw. neu gekauften Controllern) sollte man sich daher noch einmal vergewissern, dass der Controller auch tatsächlich mit der vermuteten Taktrate arbeitet und nicht z. B. den bei einigen Modellen werksseitig eingestellten internen [[Oszillator]] statt eines externen Quarzes nutzt. Die Werte der verschiedenen fuse-bits im Fehlerfall also beispielsweise mit ''[[AVRDUDE]]'' kontrollieren und falls nötig anpassen. Grundsätzlich empfiehlt sich auch immer ein Blick in die [[AVR_Checkliste]].

== Die UART-Register ==

Der UART wird über vier separate Register angesprochen. Die USARTs der ATMEGAs verfügen über mehrere zusätzliche Konfigurationsregister. Das Datenblatt gibt darüber Auskunft. Die folgende Tabelle gibt nur die Register für die UARTs der ATmega8/16/32 u.ä. wieder.

{| class="wikitable"
|-
| '''UCSRA   '''
| '''U'''ART '''C'''ontrol and '''S'''tatus '''R'''egister '''A'''. 
Hier teilt uns der UART mit, was er gerade so macht.

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''RXC'''|| '''TXC'''|| '''UDRE'''|| '''FE'''|| '''DOR'''|| '''PE'''|| '''U2X'''|| '''MPCM'''
|-
! R/W
| R|| R/W|| R|| R|| R|| R|| R/W|| R/W
|-
! Initialwert
| 0|| 0|| 1|| 0|| 0|| 0|| 0|| 0
|}

'''RXC''' (UART Receive Complete)
:Dieses Bit wird vom AVR gesetzt, wenn ein empfangenes Zeichen vom Empfangs-Schieberegister in das Empfangs-Datenregister transferiert wurde.
:Das Zeichen muss nun schnellstmöglich aus dem Datenregister ausgelesen werden. Falls dies nicht erfolgt, bevor ein weiteres Zeichen komplett empfangen wurde, wird eine Überlauf-Fehlersituation eintreten. Mit dem Auslesen des Datenregisters wird das Bit automatisch gelöscht.

'''TXC''' (UART Transmit Complete)
:Dieses Bit wird vom AVR gesetzt, wenn das im Sende-Schieberegister befindliche Zeichen vollständig ausgegeben wurde und kein weiteres Zeichen im Sendedatenregister ansteht. Dies bedeutet also, dass die Kommunikation vollumfänglich abgeschlossen ist.
:Dieses Bit ist wichtig bei Halbduplex-Verbindungen, wenn das Programm nach dem Senden von Daten auf Empfang schalten muss. Im Vollduplexbetrieb brauchen wir dieses Bit nicht zu beachten.
:Das Bit wird nur dann automatisch gelöscht, wenn der entsprechende Interrupthandler aufgerufen wird, ansonsten müssen wir das Bit selber löschen.
:Um das Bit zu löschen muss eine 1 an die entsprechende Position geschrieben werden!

'''UDRE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty)
:Dieses Bit zeigt an, ob der Sendepuffer bereit ist, um ein zu sendendes Zeichen aufzunehmen. Das Bit wird vom AVR gesetzt (1), wenn der Sendepuffer leer ist. Es wird gelöscht (0), wenn ein Zeichen im Sendedatenregister vorhanden ist und noch nicht in das Sende-Schieberegister übernommen wurde. Atmel empfiehlt aus Kompatibilitätsgründen mit kommenden µC, UDRE auf 0 zu setzen, wenn das UCSRA Register beschrieben wird.
:Das Bit wird automatisch gelöscht, wenn ein Zeichen in das Sendedatenregister geschrieben wird.

'''FE''' ('''F'''raming '''E'''rror)
:Dieses Bit wird vom AVR gesetzt, wenn der UART einen Zeichenrahmenfehler detektiert, d.h. wenn das Stopbit eines empfangenen Zeichens 0 ist.
:Das Bit wird automatisch gelöscht, wenn das Stopbit des empfangenen Zeichens 1 ist.

'''DOR''' ('''D'''ata '''O'''ver '''R'''un)
:Dieses Bit wird vom AVR gesetzt, wenn unser Programm das im Empfangsdatenregister bereit liegende Zeichen nicht abholt bevor das nachfolgende Zeichen komplett empfangen wurde.
:Das nachfolgende Zeichen wird verworfen.
:Das Bit wird automatisch gelöscht, wenn das empfangene Zeichen in das Empfangsdatenregister transferiert werden konnte.

'''PE''' ('''P'''arity '''E'''rror''')
:Dieses Bit wird vom AVR gesetzt, wenn das im Empfangsdatenregister bereit liegende Zeichen eine Paritätsfehler aufweist.
:Das Bit wird automatisch gelöscht, wenn das empfangene Zeichen in das Empfangsdatenregister transferiert werden konnte.

'''U2X''' (Double the transmission speed)
:Dieses Bit wird lediglich im asynchronen Modus genutzt. Im synchronen Modus ist es 0 zu setzen. Wird das Bit gesetzt, so wird der Baudraten Divisor von 16 auf 8 reduziert, was einer Verdopplung der Transferrate gleich kommt.

'''MPCM''' ('''M'''ulti '''P'''rozessor '''C'''ommunication '''M'''ode)
:Dieses Bit aktiviert die Multi-Prozessor-Kommunikation. Jeder eintreffende Frame der keine Adressinformation enthält wird dadurch ignoriert.

|-
| '''UCSRB    '''
| '''U'''ART '''C'''ontrol and '''S'''tatus '''R'''egister '''B'''. 
In diesem Register stellen wir ein, wie wir den UART verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''RXCIE'''|| '''TXCIE'''|| '''UDRIE'''|| '''RXEN'''|| '''TXEN'''|| '''UCSZ2'''|| '''RXB8'''|| '''TXB8'''
|-
! R/W
| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R|| R/W
|-
! Initialwert
| 0|| 0|| 0|| 0|| 0|| 0|| 0|| 0
|}

'''RXCIE''' ('''RX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART RX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART empfangen wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TXCIE''' ('''TX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART TX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART gesendet wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''UDRIE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART Datenregister Leer Interrupt ausgelöst, wenn der UART wieder bereit ist um ein neues zu sendendes Zeichen zu übernehmen. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''RXEN''' ('''R'''eceiver '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Empfänger des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''TXEN''' ('''T'''ransmitter '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Sender des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''UCSZ2''' (Characters Size)
:Dieses Bit setzt in Verbindung mit dem UCSZ1:0 Bits im UCSRC Register die Anzahl von Datenbits eines Frames beim Empfang oder Senden.

'''RXB8''' (Receive Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann enthält dieses Bit das 9. Datenbit eines empfangenen Zeichens.

'''TXB8''' (Transmit Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann muss in dieses Bit das 9. Bit des zu sendenden Zeichens eingeschrieben werden bevor das eigentliche Datenbyte in das Datenregister geschrieben wird.
|-
| '''UCSRC    '''
| '''U'''ART '''C'''ontrol and '''S'''tatus '''R'''egister '''C'''. 

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''URSEL'''|| '''UMSEL'''|| '''UPM1'''|| '''UPM0'''|| '''USBS'''|| '''UCSZ1'''|| '''UCSZ0'''|| '''UCPOL'''
|-
! R/W
| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R/W
|-
! Initialwert
| 1|| 0|| 0|| 0|| 0|| 1|| 1|| 0
|}

'''URSEL''' (Register Select)
:Dieses Bit selektiert die Auswahl des UCSRC- bzw. des UBRRH Registers. Beim Lesen von UCSRC wird es als 1 gelesen. Beim Schreiben auf UCSRC muss es auf 1 gesetzt werden.

:Achtung: Manche Prozessoren verfügen über dieses Bit, andere wiederrum nicht. Was hat es damit auf sich? Um Zugriffsadressen einzusparen, wurde von Atmel ein etwas seltsamer Weg gewählt. Das UCSRC Register und das High-Byte des Baudratenregisters teilen sich dieselbe Registeradresse! Um der Hardware mitzuteilen, welche Bedeutung ein zugewiesener Wert haben soll, entweder neue Belegung des Baudratenregisters oder eben Konfiguration des UCSRC Registers, dient dieses Bit. Ist es nicht gesetzt, dann wird eine Zuweisung immer als Zuweisung an das High-Byte des Baudratenregisters angesehen, selbst wenn das so nicht beabsichtigt war. Nur dann wenn dieses Bit gesetzt ist, dann wird eine Zuweisung auch tatsächlich als eine Zuweisung an das UCSRC Register gewertet und die Konfiguration verändert. Lässt man das Bit irrtümlich weg, dann verursacht eine Zuweisung an UCSRC eine Veränderung der Baudrateneinstellung!

'''UMSEL''' (USART Mode Select)
:Durch dieses Bit kann eine asynchrone oder synchrone Übertragung eingestellt werden. Durch Setzen des Bits wird eine synchrone Übertragung eingestellt.

'''UPM1:0''' (Parity Mode)
{| class="wikitable" style="text-align:center"
|-
| '''UPM1'''|| '''UPM0'''|| '''Parity Mode'''
|-
| 0|| 0|| Disabled
|-
| 0|| 1|| Reserved
|-
| 1|| 0|| Enabled, Even Priority
|-
| 1|| 1|| Enabled, OddPriority
|}

'''USBS''' ('''U'''SART '''S'''top '''B'''it '''S'''elect)
:Diese Bits setzen die Anzahl der zu sendenden Stopbits eines Frames. Beim Setzen werden 2 Stopbits übertragen, andernfalls nur 1 Stopbit.
{| class="wikitable" style="text-align:center"
|-
| '''USBS'''|| '''Anzahl der Stop Bits'''
|-
| 0|| 1
|-
| 1|| 2

|}

'''UCSZ1:0''' (Character Size)
:Diese Bits setzen in Verbindung mit UCSZ2 aus dem UCSRB Register die Anzahl der Datenbits eines Frames.
:Diese Bits setzen den entsprechenden Paritätsmodus.
{| class="wikitable" style="text-align:center"
|-
| '''UCSZ2'''|| '''UCSZ1'''|| '''UCSZ0'''|| '''Character Size'''
|-
| 0|| 0|| 0|| 5-Bit
|-
| 0|| 0|| 1|| 6-Bit
|-
| 0|| 1|| 0|| 7-Bit
|-
| 0|| 1|| 1|| 8-Bit
|-
| 1|| 0|| 0|| Reserved
|-
| 1|| 0|| 1|| Reserved
|-
| 1|| 1|| 0|| Reserved
|-
| 1|| 1|| 1|| 9-Bit
|}

'''UCPOL''' (Clock Polarity)

|-
| '''UDR'''
| '''U'''ART '''D'''ata '''R'''egister. 
Hier werden Daten zwischen UART und CPU übertragen. Da der UART im
Vollduplexbetrieb gleichzeitig empfangen und senden kann, handelt es sich
hier physikalisch um 2 Register, die aber über die gleiche I/O-Adresse
angesprochen werden. Je nachdem, ob ein Lese- oder ein Schreibzugriff auf
den UART erfolgt wird automatisch das richtige UDR angesprochen.
|-
| '''UBRR'''
| '''U'''ART '''B'''aud '''R'''ate '''R'''egister. 
In diesem Register müssen wir dem UART mitteilen, wie schnell wir gerne kommunizieren möchten. Der Wert, der in dieses Register geschrieben werden muss, errechnet sich nach folgender Formel (wenn U2X Bit 0 gesetzt ist):

:<math>
\mathrm{UBRR} = \frac{\mathrm{Taktfrequenz}}{\mathrm{Baudrate} \cdot 16} - 1
</math>

Es sind Baudraten bis über 115200 Baud möglich, je nach Controller und CPU-Frequenz. Siehe Datenblatt.
|}

== UART initialisieren ==

Wir wollen nun Daten mit dem UART auf die serielle Schnittstelle ausgeben. Dazu müssen wir den UART zuerst mal initialisieren. Dazu setzen wir je nach gewünschter Funktionsweise die benötigten Bits im '''U'''ART '''C'''ontrol '''R'''egister.

Da wir vorerst nur senden möchten und noch keine Interrupts auswerten wollen, gestaltet sich die Initialisierung wirklich sehr einfach, da wir lediglich das '''Transmitter Enable''' Bit setzen müssen:

<c>
UCSRB |= (1<<TXEN);
</c>

Neuere AVRs mit USART haben mehrere Konfigurationsregister und erfordern eine etwas andere Konfiguration. Für einen ATmega16 z. B.:

<c>
UCSRB |= (1<<TXEN); // UART TX einschalten
UCSRC = (1<<URSEL)|(1 << UCSZ1)|(1 << UCSZ0); // Asynchron 8N1
</c>

Nun ist noch das Baudratenregister '''UBRR''' der verwendeten UARTs einzustellen, bzw. bei neueren AVRs die beiden Register '''UBRRL''' und '''UBRRH'''. . Die Berechnung wird während des Compilerlaufs ausgeführt, beansprucht also in der gezeigten Form weder Speicher noch Rechenzeit des Controllers. Das Ergebniss wird jedoch als ganzzahliger Wert eingesetzt, d.h. Nachkommastellen werden einfach abgeschnitten und es erfolgt keine Rundung. Aus diesem Grund kann man sich eines kleinen Tricks bedienen, indem vor der eigentlichen Division bei der Zuweisung die Hälfte des Wertes dazu addiert wird. Allgemein formuliert bedeutet das: <code>int i = ( a + b/2 ) / b;</code>. Dies wird in der unten angegebenen Berechnung von UBRR_VAL ausgenutzt um den Fehler zu minimieren. (Eine ausführliche Erklärung zum ''cleveren Runden'' findet sich in einer [http://www.mikrocontroller.net/topic/170617#1631916 Forumsdiskussion].)

<c>
/*
UART-Init:
Berechnung des Wertes für das Baudratenregister
aus Taktrate und gewünschter Baudrate
*/

#ifndef F_CPU
/* In neueren Version der WinAVR/Mfile Makefile-Vorlage kann
F_CPU im Makefile definiert werden, eine nochmalige Definition
hier wuerde zu einer Compilerwarnung fuehren. Daher "Schutz" durch
#ifndef/#endif

Dieser "Schutz" kann zu Debugsessions führen, wenn AVRStudio
verwendet wird und dort eine andere, nicht zur Hardware passende
Taktrate eingestellt ist: Dann wird die folgende Definition
nicht verwendet, sondern stattdessen der Defaultwert (8 MHz?)
von AVRStudio - daher Ausgabe einer Warnung falls F_CPU
noch nicht definiert: */
#warning "F_CPU war noch nicht definiert, wird nun nachgeholt mit 4000000"
#define F_CPU 4000000UL // Systemtakt in Hz - Definition als unsigned long beachten
// Ohne ergeben sich unten Fehler in der Berechnung
#endif

#define BAUD 9600UL // Baudrate

// Berechnungen
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1) // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1))) // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.

#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
#error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!
#endif
</c>

Die Makros sind sehr praktisch, da damit sowohl automatisch der Wert für UBRR, als auch die Abweichung in der generierten (möglichen) von der gewünschten Baudrate berechnet wird. Im Falle einer zu hohen Abweichung (+/-1%) wird eine Fehlermeldung ausgegeben und der Compilerablauf abgebrochen. Damit können viele Probleme mit "UART sendet komische Zeichen" vermieden werden. Ausserdem kann man mühelos die Einstellung an eine neue Taktfrequenz bzw. Baudrate anpassen, ohne selber rechnen oder in Tabellen nachschlagen zu müssen.

Die eigentliche Initialisierung der UART Register kann im Hauptprogramm main() vorgenommen werden. Öfters wird jedoch eine Funktion z. B. uart_init() dafür geschrieben, die in der eigenen Codesammlung in mehreren Projekten verwendet werden kann.

Für einige AVR (z. B. ATmega169, ATmega48/88/168, AT90CAN jedoch nicht für z. B. ATmega16/32, ATmega128, ATtiny2313) wird durch die Registerdefinitionen der avr-libc (io*.h) auch für Controller mit zwei UBRR-Registern (UBRRL/UBRRH) ein UBRR bzw. UBRR0 als "16-bit-Register" definiert und man kann den Wert direkt per UBRR = UBRR_VAL zuweisen. Intern werden dann zwei Zuweisungen für UBRRH und UBRRL generiert.

<c>
/* UART-Init Bsp. ATmega48 */

void uart_init(void)
{
UBRR0 = UBRR_VAL;
UCSR0B |= (1<<TXEN0);
// Frame Format: Asynchron 8N1
UCSR0C = (1<<UCSZ01)|(1<<UCSZ00);
}
</c>

Die einzelne Anweisung ist nicht bei allen Controllern möglich, da die beiden Register nicht bei allen aufeinanderfolgende Addressen aufweisen. Die getrennte Zuweisung an UBRRH und UBRRL wie im nächsten Beispiel gezeigt, ist universeller und portabler und daher vorzuziehen. Wichtig ist, dass UBRRH '''vor''' UBRRL geschrieben wird:

<c>
/* UART-Init Bsp. ATmega16 */

void uart_init(void)
{
UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL & 0xFF;

UCSRB |= (1<<TXEN); // UART TX einschalten
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // Asynchron 8N1
}
</c>

Inzwischen gibt es in der avr-libc Makros für obige Berechnung der UBRR Registerwerte aus Taktrate F_CPU und Baudrate BAUD. Dazu wird die Includedatei [http://www.nongnu.org/avr-libc/user-manual/group__util__setbaud.html <util/setbaud.h>] eingebunden, nachdem F_CPU und die gewünschte Baudrate definiert wurden. Einige Beispiele zur Anwendung finden sich in der Dokumentation der avr-libc. Im Quellcode kann dann analog zur oben gezeigten Vorgehensweise einfach das Makro UBRR_VALUE (bzw. UBRRH_VALUE und UBRRL_VALUE) an der entsprechenden Stelle eingesetzt werden. Es wird auch automatisch ermittelt, ob der U2X-Modus (vgl. Datenblatt) zu geringeren Abweichungen führt und dann dem Makro USE_U2X ein Wert ungleich null zugewiesen. Ein Beispiel (angelehnt an die avr-libc-Dokumentation):

<c>
#include <avr/io.h>
#define F_CPU 1000000 /* evtl. bereits via Compilerparameter definiert */
#define BAUD 9600
#include <util/setbaud.h>

void uart_init(void)
{
UBRRH = UBRRH_VALUE;
UBRRL = UBRRL_VALUE;
/* evtl. verkuerzt falls Register aufeinanderfolgen (vgl. Datenblatt)
UBRR = UBRR_VALUE;
*/
#if USE_2X
/* U2X-Modus erforderlich */
UCSRA |= (1 << U2X);
#else
/* U2X-Modus nicht erforderlich */
UCSRA &= ~(1 << U2X);
#endif

// hier weitere Initialisierungen (TX und/oder RX aktivieren, Modus setzen
}
</c>

Siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/group__util__setbaud.html Dokumentation der avr-libc zu <util/setbaud.h>]
* [http://www.wormfood.net/avrbaudcalc.php WormFood's AVR Baud Rate Calculator] online.
* [http://www.gjlay.de/helferlein/avr-uart-rechner.html AVR Baudraten-Rechner] in JavaScript

== Senden mit dem UART ==

=== Senden einzelner Zeichen ===

Um nun ein Zeichen auf die Schnittstelle auszugeben, müssen wir dasselbe
lediglich in das '''U'''ART '''D'''ata '''R'''egister schreiben. Vorher ist zu prüfen, ob das UART-Modul bereit ist, das zu sendende Zeichen entgegenzunehmen. Die Bezeichnungen des/der Statusregisters mit dem Bit UDRE ist abhängig vom Controllertypen (vgl. Datenblatt).

<c>
// bei neueren AVRs steht der Status in UCSRA/UCSR0A/UCSR1A, hier z. B. fuer ATmega16:
while (!(UCSRA & (1<<UDRE))) /* warten bis Senden moeglich */
{
}

UDR = 'x'; /* schreibt das Zeichen x auf die Schnittstelle */
</c>

=== Schreiben einer Zeichenkette (String) ===

Die Aufgabe "String senden" wird durch zwei Funktionen abgearbeitet. Die universelle/controllerunabhängige Funktion uart_puts übergibt jeweils ein Zeichen der Zeichenkette an eine Funktion uart_putc, die abhängig von der vorhandenen Hardware implementiert werden muss. In der Funktion zum Senden eines Zeichens ist darauf zu achten, dass vor dem Senden geprüft wird, ob der UART bereit ist den "Sendeauftrag" entgegenzunehmen.

<c>
/* ATmega16 */
int uart_putc(unsigned char c)
{
while (!(UCSRA & (1<<UDRE))) /* warten bis Senden moeglich */
{
}

UDR = c; /* sende Zeichen */
return 0;
}

/* puts ist unabhaengig vom Controllertyp */
void uart_puts (char *s)
{
while (*s)
{ /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
uart_putc(*s);
s++;
}
}
</c>

Die in uart_putc verwendeten Schleifen, in denen gewartet wird bis die UART-Hardware zum senden bereit ist, sind insofern etwas kritisch, da während des Sendens eines Strings nicht mehr auf andere Ereignisse reagiert werden kann. Universeller ist die Nutzung von FIFO(first-in first-out)-Puffern, in denen die zu sendenden bzw. empfangenen Zeichen/Bytes zwischengespeichert und in Interruptroutinen an die U(S)ART-Hardware weitergegeben bzw. von ihr ausgelesen werden. Dazu existieren fertige Komponenten (Bibliotheken, Libraries), die man recht einfach in eigene Entwicklungen integrieren kann. Es empfiehlt sich, diese Komponenten zu nutzen und das Rad nicht neu zu erfinden.

=== Schreiben von Variableninhalten ===

Sollen Inhalte von Variablen (Ganzzahlen, Gleitkomma) in "menschenlesbarer" Form gesendet werden, ist vor dem Transfer eine Umwandlung in Zeichen ("ASCII") erforderlich. Bei nur einer Ziffer ist diese Umwandlung relativ einfach: man addiert den ASCII-Wert von Null zur Ziffer und kann diesen Wert direkt senden.

<c>
#include <avr/io.h>
#include <stdlib.h>
//...

// hier uart_putc (s.o.)

int main (void)
{
// Ausgabe von 0123456789
char c;

uart_init();

for (uint8_t i=0; i<=9; ++i) {
c = i + '0';
uart_putc( c );
// verkuerzt: uart_putc( i + '0' );
}

while (1) {
;
}

return 0; // never reached

}
</c>

Soll mehr als eine Ziffer ausgegeben werden, bedient man sich zweckmäßigerweise vorhandener Funktionen zur Umwandlung von Zahlen in Zeichenketten/Strings. Die Funktion der avr-libc zur Umwandlung von vorzeichenbehafteten 16bit-Ganzzahlen (int16_t) in Zeichenketten heißt ''itoa'' (Integer to ASCII). Man muss der Funktion einen Speicherbereich zur Verarbeitung (buffer) mit Platz für alle Ziffern, das String-Endezeichen ('\0') und evtl. das Vorzeichen bereitstellen.

<c>
#include <avr/io.h>
#include <stdlib.h>

//...

// hier uart_init, uart_putc, uart_puts (s.o.)

int main(void)
{
char s[7];
int16_t i = -12345;

uart_init();

itoa( i, s, 10 ); // 10 fuer radix -> Dezimalsystem
uart_puts( s );

// da itoa einen Zeiger auf den Beginn von s zurueckgibt verkuerzt auch:
uart_puts( itoa( i, s, 10 ) );

while (1) {
;
}

return 0; // never reached
}
</c>

Für vorzeichenlose 16bit-Ganzzahlen (uint16_t) exisitert ''utoa''. Die Funktionen für 32bit-Ganzzahlen (int32_t und uint32_t) heißen ''ltoa'' bzw. ''ultoa''. Da 32bit-Ganzzahlen mehr Stellen aufweisen können, ist ein entsprechend größerer Pufferspeicher vorzusehen.

Auch Gleitkommazahlen (float/double) können mit bereits vorhandenen Funktionen in Zeichenfolgen umgewandelt werden, dazu existieren die Funktionen ''dtostre'' und ''dtostrf''. dtostre nutzt Exponentialschreibweise ("engineering"-Format). (Hinweis: z.Zt. existiert im avr-gcc kein "echtes" double, intern wird immer mit "einfacher Genauigkeit", entsprechend float, gerechnet.)

dtostrf und dtostre benötigen die libm.a der avr-libc. Bei Nutzung von Makefiles ist der Parameter -lm in in LDFLAGS anzugeben (Standard in den WinAVR/mfile-Makefilevorlagen). Nutzt man AVRStudio als IDE für den GNU-Compiler (gcc-Plugin) ist die libm.a unter Libaries auszuwählen: Project -> Configurations Options -> Libaries -> libm.a mit dem Pfeil nach rechts einbinden. Siehe auch die [[FAQ#Aktivieren_der_Floating_Point_Version_von_sprintf_beim_WinAVR_mit_AVR-Studio|FAQ]]

<c>
#include <avr/io.h>
#include <stdlib.h>

//...

// hier uart_init, uart_putc, uart_puts (s.o.)

/* lt. avr-libc Dokumentation:
char* dtostrf(
double __val,
char __width,
char __prec,
char * __s
)
*/

int main(void)
{
// Pufferspeicher ausreichend groß
// evtl. Vorzeichen + width + Endezeichen:
char s[8];
float f = -12.345;

uart_init();

dtostrf( f, 6, 3, s );
uart_puts( s );
// verkürzt: uart_puts( dtostrf( f, 7, 3, s ) );

while (1) {
;
}

return 0; // never reached
}
</c>

== Empfangen ==
=== Einzelne Zeichen empfangen ===

Zum Empfang von Zeichen muss der Empfangsteil des UART bei der Initialisierung aktiviert werden, indem das RXEN-Bit im jeweiligen Konfigurationsregister (UCSRB bzw UCSR0B/UCSR1B) gesetzt wird. Im einfachsten Fall wird solange gewartet, bis ein Zeichen empfangen wurde, dieses steht dann im UART-Datenregister (UDR bzw. UDR0 und UDR1 bei AVRs mit 2 UARTS) zur Verfügung (sogen. "Polling-Betrieb"). Ein Beispiel für den ATmega16:

<c>
#include <inttypes.h>
#include <avr/io.h>

/* Siehe auch obere Baudrateneinstellung */
/* USART-Init beim ATmega16 */

void uart_init(void)
{
UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL & 0xFF;

UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // Asynchron 8N1
UCSRB |= (1<<RXEN); // UART RX einschalten
}

/* Zeichen empfangen */
uint8_t uart_getc(void)
{
while (!(UCSRA & (1<<RXC))) // warten bis Zeichen verfuegbar
;
return UDR; // Zeichen aus UDR an Aufrufer zurueckgeben
}
</c>

Und die Anwendung in einem Beispiel:

<c>
#include <avr/io.h>
#include <stdlib.h>

// hier Makro für die Baudratenberechnung

// hier uart_init, uart_getc (s.o.)

int main(void)
{
uart_init();
while (1)
{
uint8_t c;
c = uart_getc();

// hier etwas mit c machen z.B. auf PORT ausgeben
DDRC = 0xFF; // PORTC Ausgang
PORTC = c;
}
return 0; // never reached
}
</c>

Die Funktion uart_getc() blockiert allerdings den Programmablauf, denn es wird gewartet, bis ein Zeichen empfangen wird! Möchte man das Warten vermeiden, kann das RXC-Bit in einer Programmschleife abgefragt werden und dann nur bei gesetztem RXC-Bit UDR ausgelesen werden.

<c>
#include <avr/io.h>
#include <stdlib.h>

// hier Makro für die Baudratenberechnung

// hier uart_init, uart_getc (s.o.)

int main(void)
{
uart_init();
while (1)
{
if ( (UCSRA & (1<<RXC)) )
{
// Zeichen wurde empfangen, jetzt abholen
uint8_t c;
c = uart_getc();
// hier etwas mit c machen z.B. auf PORT ausgeben
DDRC = 0xFF; // PORTC Ausgang
PORTC = c;
}
else
{
// Kein Zeichen empfangen, Restprogramm ausführen...
}
}
return 0; // never reached
}
</c>

Eleganter und in den meisten Anwendungsfällen "stabiler" ist die Vorgehensweise, die empfangenen Zeichen in einer Interrupt-Routine einzulesen und zur späteren Verarbeitung in einem Eingangsbuffer (FIFO-Buffer) zwischenzuspeichern. Dazu existieren fertige und gut getestete [[Libraries|Bibliotheken]]  und Quellcodekomponenten (z. B. UART-Library von P. Fleury, procyon-avrlib und einige in der "Academy" von avrfreaks.net).

Siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/group__avr__stdlib.html Dokumenation der avr-libc/stdlib.h]
* [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Die_Nutzung_von_sprintf_und_printf Die Nutzung von sprintf und printf]
* [http://homepage.hispeed.ch/peterfleury/ Peter Fleurys] UART-Bibiliothek fuer avr-gcc/avr-libc


TODO: 9bit

=== Empfang von Zeichenketten (Strings) ===

Beim Empfang von Zeichenketten, muß man sich zunächst darüber im klaren sein, daß es ein Kriterium geben muß, an dem der µC erkennen kann, wann ein Text zu Ende ist. Sehr oft wird dazu das Zeichen 'Return' benutzt, um das Ende eines Textes zu markieren. Dies ist vom Benutzer einfach eingebbar und er ist auch daran gewöhnt, daß er eine Eingabezeile mit einem Druck auf die Return Taste abgeschlossen wird.

Prinzipiell gibt es jedoch keine Einschränkung bezüglich dieses speziellen Zeichens. Es muß nur sichergestellt werden, daß dieses spezielle 'Ende eines Strings' - Zeichen nicht mit einem im Text vorkommenden Zeichen verwechselt werden kann. Wenn also im zu übertragenden Text beispielsweise kein ';' vorkommt, dann spricht nichts dagegen, den Benutzer die Eingabe eines Textes mit einem ';' abschließen zu lassen.

Im Folgenden wird die durchaus übliche Annahme getroffen, daß eine Stringübertragung identisch ist mit der Übertragung einer Textzeile und daher mit einem Return ('\n') abgeschlossen wird.

Das Problem der Übertragung eines Strings reduziert sich damit auf die Aufgabenstellung: Empfange und sammle Zeichen in einem char Array, bis entweder das Array voll ist oder das Text Ende Zeichen' empfangen wurde. Danach wird der empfangene Text noch mit einem '\0' Zeichen abgeschlossen um einen Standard C-String daraus zu machen, mit dem dann weiter gearbeitet werden kann.

<C>
/* Zeichen empfangen */
uint8_t uart_getc(void)
{
while (!(UCSRA & (1<<RXC))) // warten bis Zeichen verfuegbar
;
return UDR; // Zeichen aus UDR an Aufrufer zurueckgeben
}

void uart_gets( char* Buffer, uint8_t MaxLen )
{
uint8_t NextChar;
uint8_t StringLen = 0;

NextChar = uart_getc(); // Warte auf und empfange das nächste Zeichen

// Sammle solange Zeichen, bis:
// * entweder das String Ende Zeichen kam
// * oder das aufnehmende Array voll ist
while( NextChar != '\n' && StringLen < MaxLen - 1 ) {
*Buffer++ = NextChar;
StringLen++;
NextChar = uart_getc();
}

// Noch ein '\0' anhängen um einen Standard
// C-String daraus zu machen
*Buffer = '\0';
}
</C>

Beim Aufruf ist darauf zu achten, dass das empfangende Array auch mit einer
vernünftigen Größe definiert wird.

<C>

char Line[40]; // String mit maximal 39 zeichen

uart_gets( Line, sizeof( Line ) );
</C>

Bei der Benutzung von sizeof() ist allerdings zu beachten, dass sizeof() nicht die Anzahl der Elemente des Arrays liefert, sondern die Länge in Byte. Da ein char nur ein Byte lang ist, passt der Aufruf 'uart_gets(Line, sizeof( Line ) );' in diesem Fall. Falls man - aus welchen Gründen auch immer - andere Datentypen benutzen möchte, sollte man zur korrekten Angabe der Array-Länge folgende Vorgehensweise bevorzugen:

<C>
int Line[40]; // Array vom Typ int

uart_gets( Line, sizeof( Line ) / sizeof( Line[0] ) );
</C>

==Interruptbetrieb==

Hier wird das Grundwissen des Artikels [[Interrupt]] und des Abschnitts [[AVR-GCC-Tutorial#Programmieren_mit_Interrupts|AVR-GCC-Tutorial: Programmieren_mit_Interrupts]] vorausgesetzt.

=== Empfangen (RX) ===

Beim ATmega8 muss das '''RXCIE''' Bit im Register UCSRB gesetzt werden, damit ein Interrupt beim Empfang eines Zeichens ausgelöst werden kann.

<c>
/* siehe auch obere Baudrateneinstellung */
/* USART-Init beim ATmega16 */
void uart_init(void)
{
UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL & 0xFF;
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // Asynchron 8N1
UCSRB |= (1<<RXEN)|(1<<TXEN)|(1<<RXCIE); // UART RX, TX und RX Interrupt einschalten
}
</c>

Natürlich muss "Global Interrupt Enable" mittels des Befehls sei() aktiviert sein. Interrupt-spezifische Definitionen werden über die Includedatei eingebunden:

<c>
#include <avr/interrupt.h>
</c>

Der Interrupt wird immer ausgelöst, wenn ein Zeichen erfolgreich empfangen wurde. Zusätzlich braucht man die Interruptserviceroutine (ISR).

In diesem Beispiel enthält die ISR einen FIFO-Puffer (First in, First out). Dafür werden ein paar globale Variablen und Makros benötigt:

<c>
#define UART_MAXSTRLEN 10

volatile uint8_t uart_str_complete = 0; // 1 .. String komplett empfangen
volatile uint8_t uart_str_count = 0;
volatile char uart_string[UART_MAXSTRLEN + 1] = "";
</c>

<c>
ISR(USART_RXC_vect)
{
unsigned char nextChar;

// Daten aus dem Puffer lesen
nextChar = UDR;
if( uart_str_complete == 0 ) { // wenn uart_string gerade in Verwendung, neues Zeichen verwerfen

// Daten werden erst in uart_string geschrieben, wenn nicht String-Ende/max Zeichenlänge erreicht ist/string gerade verarbeitet wird
if( nextChar != '\n' &&
nextChar != '\r' &&
uart_str_count < UART_MAXSTRLEN - 1 ) {
uart_string[uart_str_count] = nextChar;
uart_str_count++;
}
else {
uart_string[uart_str_count] = '\0';
uart_str_count = 0;
uart_str_complete = 1;
}
}
}
</c>

Zur Funktion: Wurde eine komplette Zeichenkette empfangen, also das Ende (\n oder \r) erkannt oder die maximale Länge ''UART_MAXSTRLEN'' erreicht, wird die globale Variable ''uart_str_complete'' auf '1' gesetzt. Damit wird dem Hauptprogramm, welches auf diese Variable pollt, mitgeteilt, dass die Zeichenkette ''uart_string'' zur Verarbeitung bereit steht. Nach der Verarbeitung der Zeichenkette in der entsprechenden main-Routine, muss die Variable ''uart_str_complete'' wieder auf '0' zurück gesetzt werden. Dadurch werden alle neu empfangenen Zeichen wieder in den globalen Puffer geschrieben.

=== (Baustelle) ===

* Empfangen (Receive) (Anm.: z.T. erledigt)
** ggf. Fallstricke ([http://www.mikrocontroller.net/topic/84256#707214 UDR in der ISR lesen!])
** Komplettes, einfaches Beispiel ([http://www.mikrocontroller.net/topic/84228#707052 Echo] (noch buggy beim Datenzugriff, siehe Lit. 2+3!)), ggf. LED zur ISR-Empfangsanzeige oder Overflow-Anzeige

* Senden (Transmit)
** Variante "UART Data Register Empty" (UDRE) [http://www.mikrocontroller.net/topic/101472#882716]
** Variante "UART Transmit Complete" (TXC)

* FIFO-Puffer [http://www.mikrocontroller.net/topic/101472#882716], Ringpuffer (Byte Buffering (circular))

* UART-Bibliotheken
** [http://homepage.hispeed.ch/peterfleury/avr-software.html UART-Library] von Peter Fleury (UART (interrupt driven), Byte Buffering (circular))
** [http://beaststwo.org/avr-uart/index.shtml Updated AVR UART Library] (modernisierte und erweiterte Version der Bibliothek von Peter Fleury)
** [http://www.procyonengineering.com/embedded/avr/avrlib/ Procyon AVRlib] von Pascal Stang (UART (interrupt driven), Byte Buffering (circular), VT100 Terminal Output)

* Literatur
** [http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=48188 avrfreaks.net Tutorial] inkl. Diskussion (engl.)
** avr-libc FAQ: [http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_16bitio Why do some 16-bit timer registers sometimes get trashed?]

==Software-UART==

Falls die Zahl der vorhandenen Hardware-UARTs nicht ausreicht, können weitere Schnittstellen über sogennante Software-UARTs ergänzt werden. Es gibt dazu (mindestens) zwei Ansätze:
* Der bei AVRs üblichste Ansatz basiert auf dem Prinzip, dass ein externer Interrupt-Pin für den Empfang ("RX") genutzt wird. Das Startbit löst den Interrupt aus, in der Interrupt-Routine (ISR) wird der externe Interrupt deaktiviert und ein Timer aktiviert. In der Interrupt-Routine des Timers wird der Zustand des Empfangs-Pins entsprechend der Baudrate abgetastet. Nach Empfang des Stop-Bits wird der externe Interrupt wieder aktiviert. Senden kann über einen beliebigen Pin ("TX") erfolgen, der entsprechend der Baudrate und dem zu sendenden Zeichen auf 0 oder 1 gesetzt wird. Die Implementierung ist nicht ganz einfach, es existieren dazu aber fertige Bibliotheken (z. B. bei [http://www.avrfreaks.net/ avrfreaks] oder in der [http://www.procyonengineering.com/embedded/avr/avrlib/ Procyon avrlib]).
* Ein weiterer Ansatz erfordert keinen Pin mit "Interrupt-Funktion" aber benötigt mehr Rechenzeit. Jeder Input-Pin kann als Empfangspin (RX) dienen. Über einen Timer wird der Zustand des RX-Pins mit einem vielfachen der Baudrate abgetastet (dreifach scheint üblich) und High- bzw. Lowbits anhand einer Mindestanzahl identifiziert. (Beispiel: "Generic Software Uart" Application-Note von IAR)

Neuere AVRs (z. B. ATtiny26 oder ATmega48,88,168,169) verfügen über ein Universal Serial Interface (USI), das teilweise UART-Funktion übernehmen kann. Atmel stellt eine Application-Note bereit, in der die Nutzung des USI als UART erläutert wird (im Prinzip "Hardware-unterstützter Software-UART").

==Handshaking==
Wenn der Sender ständig sendet, wird irgendwann der Fall eintreten, daß der Empfänger nicht bereit ist, neue Zeichen zu empfangen. In diesem Fall muß durch ein '''Handshake-Verfahren''' die Situation bereinigt werden. Handshake bedeutet nichts anderes, als daß der Empfänger dem Sender mitteilt, daß er zur Zeit keine Daten annehmen kann und der Sender die Übertragung der nächsten Zeichen solange einstellen soll, bis der Empfänger signalisiert, daß er wieder Zeichen aufnehmen kann.
===Hardwarehandshake (RTS/CTS)===
Beim Hardwarehandshake werden zusätzlich zu den beiden Daten-Übertragungsleitungen noch 2 weitere Leitungen benötigt: '''RTS''' ('''R'''equest '''T'''o '''S'''end) und '''CTS''' ('''C'''lear '''T'''o '''S'''end). Jeder der beiden Kommunikationspartner ist verpflichtet, bevor ein Zeichen gesendet wird, den Zustand der '''RTS''' Leitung zu überprüfen. Nur wenn die Gegenstelle darauf Empfangsbereitschaft signalisiert, darf das Zeichen gesendet werden. Um der Gegenstelle zu signalisieren, daß sie zur Zeit keine Zeichen schicken soll, wird die Leitung '''CTS''' benutzt.

===Softwarehandshake (XON/XOFF)===
Beim Softwarehandshake sind keine speziellen Leitungen notwendig. Stattdessen werden besondere ASCII-Zeichen benutzt, die der Gegenstelle signalisieren, das Senden einzustellen bzw. wieder aufzunehmen.

* '''XOFF''' Aufforderung das Senden einzustellen
* '''XON''' Gegenstelle darf wieder senden

Nachteilig bei einem Softwarehandshake ist, dass dadurch keine direkte binäre Datenübertragung mehr möglich ist, denn von den möglichen 256 Bytewerten werden ja nun zwei (nämlich für '''XON''' und für '''XOFF''') für besondere Zwecke benutzt und fallen daher aus. In einem quasi-zufälligen Bytestrom, den eine Binärdatei darstellt, kämen diese beiden reservierten früher oder später vor und würden dann den Strom ungewollt stoppen und starten.

==Galvanische Trennung==
Für eine geringe Überspannungsfestigkeit empfielt es sich, die Datenkanäle über Optokoppler zu führen. Es bietet sich z.b. der 6N138 an, ein "normaler" CNY-17 ist für hohe Baudraten nicht brauchbar.

==Fehlersuche==
Erstaunlich oft wird im Forum der Hilferuf laut: "Meine UART funktioniert nicht, was mache ich falsch". In der überwiegenden Mehrzahl der Fälle stellt sich dann heraus, daß es sich um ein Hardwareproblem handelt, wobei da wiederrum der Löwenanteil auf das Konto einer nicht korrekt eingestellten Taktrate geht: Der µC benutzt nicht einen angeschlossenen Quarz, so wie er auch im Programm eingetragen ist, sondern läuft immer noch mit dem internen RC-Takt. Daraus resultiert aber auch, daß der Baudraten Konfigurationswert falsch berechnet wird.

Hilfreich zum Aufspüren solcher Fehler ist auch die [[AVR_Checkliste#UART/USART|AVR-Checkliste]].

==Links==
Tipps zur Verarbeitung von Strings sind in den [[FAQ]].

[[Kategorie:avr-gcc Tutorial]]
[[Kategorie:UART und RS232]]

Aquarium-Steuerung

2011-09-29T12:54:48Z

145.225.60.4: /* Beschreibung */

== Beschreibung ==

Hallo zusammen,

momentan versuche ich mich an einer Aquarium Steuerung. Als Controller fungiert ein PIC18F47J53. Dieser besitzt unter anderem 128kB Flash, 12 Bit A/D Wandler, USB. Zum einstellen der Parameter wird dieser per USB mit einem PC verbunden.

Momentaner Stand:

* LCD Display Ausgabe
* Temperaturmessung mittels DS18B20
* Berechnung von Sonnenauf/untergang
* Berechnen von Mondphase

== Links ==
* PIC18F47J53 Datenblatt [http://ww1.microchip.com/downloads/en/DeviceDoc/39964B.pdf]
* MCP79410 Datenblatt [http://ww1.microchip.com/downloads/en/DeviceDoc/22266C.pdf]

AVR-GCC-Tutorial/Der UART

2011-07-27T10:02:40Z

145.225.60.4: /* Empfangen (RX) */

Über den [[UART]] kann ein [[AVR]] leicht mit einer [[RS-232]]-Schnittstelle eines PC oder sonstiger Geräte mit "[[seriell]]er Schnittstelle" verbunden werden.

== Allgemeines zum UART ==

Mögliche Anwendungen des UART:

;Debug-Schnittstelle: z. B. zur Anzeige von Zwischenergebnissen ("printf-debugging" - hier besser "Logging" oder "UART-debugging") über [[RS-232]] auf einem PC. Auf dem Rechner reicht dazu ein [[RS-232#Terminalprogramme|Terminalprogramm]] (MS-Windows: Hyperterm oder besser [https://sites.google.com/site/terminalbpp/], [http://www.der-hammer.info/terminal/ HTerm]; Unix/Linux z. B. minicom). Ein direkter Anschluss ist aufgrund unterschiedlicher Pegel nicht möglich, jedoch sind entsprechende Schnittstellen-ICs wie z. B. ein MAX232 günstig und leicht zu integrieren. Rechner ohne serielle Schnittstelle können über fertige USB-seriell-Adapter angeschlossen werden.
;Mensch-Maschine Schnittstelle: z. B. Konfiguration und Statusabfrage über eine "Kommandozeile" oder Menüs (siehe z. B. Forumsbeitrag [http://www.mikrocontroller.net/topic/52985 Auswertung RS232-Befehle] und Artikel [[Tinykon]])
;Übertragen von gespeicherten Werten: z. B. bei einem Datenlogger
;Anschluss von Geräten: mit serieller Schnittstelle (z. B. (Funk-)Modems, Mobiltelefone, Drucker, Sensoren, "intelligente" LC-Displays, GPS-Empfänger).
;"Feldbusse": auf RS485/RS422-Basis mittels entsprechenden Bustreiberbausteinen (z. B. MAX485)
;DMX, Midi: etc.
;LIN-Bus: '''L'''ocal '''I'''nterconnect '''N'''etwork: Preiswerte Sensoren/Aktoren in der Automobiltechnik und darüber hinaus

Einige AVR-Controller haben ein bis zwei vollduplexfähige UART ('''U'''niversal '''A'''synchronous '''R'''eceiver and '''T'''ransmitter) schon eingebaut ("Hardware-UART").
Übrigens: Vollduplex heißt nichts anderes, als dass der Baustein gleichzeitig senden und empfangen kann.

Neuere AVRs (ATmega, ATtiny) verfügen über einen bis vier U'''S'''ART(s), dieser unterscheidet sich vom UART hauptsächlich durch interne FIFO-Puffer für Ein- und Ausgabe und erweiterte Konfigurationsmöglichkeiten. Die Puffergröße ist allerdings nur 1 Byte.

== Die Hardware ==

Der UART basiert auf normalem TTL-Pegel mit 0V (logisch 0) und 5V (logisch 1). Die Schnittstellenspezifikation für RS-232 definiert jedoch -3V ... -12V (logisch 1) und
+3 ... +12V (logisch 0). Daher muss der Signalaustausch zwischen AVR und Partnergerät invertiert werden. Für die Anpassung der Pegel und das Invertieren der Signale gibt es fertige Schnittstellenbausteine. Der bekannteste davon ist wohl der MAX232.


Streikt die Kommunikation per UART, so ist oft eine fehlerhafte Einstellung der Baudrate die Ursache. Die Konfiguration auf eine bestimmte Baudrate ist abhängig von der Taktfrequenz des Controllers. Gerade bei neu aufgebauten Schaltungen (bzw. neu gekauften Controllern) sollte man sich daher noch einmal vergewissern, dass der Controller auch tatsächlich mit der vermuteten Taktrate arbeitet und nicht z. B. den bei einigen Modellen werksseitig eingestellten internen [[Oszillator]] statt eines externen Quarzes nutzt. Die Werte der verschiedenen fuse-bits im Fehlerfall also beispielsweise mit ''[[AVRDUDE]]'' kontrollieren und falls nötig anpassen. Grundsätzlich empfiehlt sich auch immer ein Blick in die [[AVR_Checkliste]].

== Die UART-Register ==

Der UART wird über vier separate Register angesprochen. Die USARTs der ATMEGAs verfügen über mehrere zusätzliche Konfigurationsregister. Das Datenblatt gibt darüber Auskunft. Die folgende Tabelle gibt nur die Register für die UARTs der ATmega8/16/32 u.ä. wieder.

{| class="wikitable"
|-
| '''UCSRA   '''
| '''U'''ART '''C'''ontrol and '''S'''tatus '''R'''egister '''A'''. 
Hier teilt uns der UART mit, was er gerade so macht.

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''RXC'''|| '''TXC'''|| '''UDRE'''|| '''FE'''|| '''DOR'''|| '''PE'''|| '''U2X'''|| '''MPCM'''
|-
! R/W
| R|| R/W|| R|| R|| R|| R|| R/W|| R/W
|-
! Initialwert
| 0|| 0|| 1|| 0|| 0|| 0|| 0|| 0
|}

'''RXC''' (UART Receive Complete)
:Dieses Bit wird vom AVR gesetzt, wenn ein empfangenes Zeichen vom Empfangs-Schieberegister in das Empfangs-Datenregister transferiert wurde.
:Das Zeichen muss nun schnellstmöglich aus dem Datenregister ausgelesen werden. Falls dies nicht erfolgt, bevor ein weiteres Zeichen komplett empfangen wurde, wird eine Überlauf-Fehlersituation eintreten. Mit dem Auslesen des Datenregisters wird das Bit automatisch gelöscht.

'''TXC''' (UART Transmit Complete)
:Dieses Bit wird vom AVR gesetzt, wenn das im Sende-Schieberegister befindliche Zeichen vollständig ausgegeben wurde und kein weiteres Zeichen im Sendedatenregister ansteht. Dies bedeutet also, dass die Kommunikation vollumfänglich abgeschlossen ist.
:Dieses Bit ist wichtig bei Halbduplex-Verbindungen, wenn das Programm nach dem Senden von Daten auf Empfang schalten muss. Im Vollduplexbetrieb brauchen wir dieses Bit nicht zu beachten.
:Das Bit wird nur dann automatisch gelöscht, wenn der entsprechende Interrupthandler aufgerufen wird, ansonsten müssen wir das Bit selber löschen.

'''UDRE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty)
:Dieses Bit zeigt an, ob der Sendepuffer bereit ist, um ein zu sendendes Zeichen aufzunehmen. Das Bit wird vom AVR gesetzt (1), wenn der Sendepuffer leer ist. Es wird gelöscht (0), wenn ein Zeichen im Sendedatenregister vorhanden ist und noch nicht in das Sende-Schieberegister übernommen wurde. Atmel empfiehlt aus Kompatibilitätsgründen mit kommenden µC, UDRE auf 0 zu setzen, wenn das UCSRA Register beschrieben wird.
:Das Bit wird automatisch gelöscht, wenn ein Zeichen in das Sendedatenregister geschrieben wird.

'''FE''' ('''F'''raming '''E'''rror)
:Dieses Bit wird vom AVR gesetzt, wenn der UART einen Zeichenrahmenfehler detektiert, d.h. wenn das Stopbit eines empfangenen Zeichens 0 ist.
:Das Bit wird automatisch gelöscht, wenn das Stopbit des empfangenen Zeichens 1 ist.

'''DOR''' ('''D'''ata '''O'''ver '''R'''un)
:Dieses Bit wird vom AVR gesetzt, wenn unser Programm das im Empfangsdatenregister bereit liegende Zeichen nicht abholt bevor das nachfolgende Zeichen komplett empfangen wurde.
:Das nachfolgende Zeichen wird verworfen.
:Das Bit wird automatisch gelöscht, wenn das empfangene Zeichen in das Empfangsdatenregister transferiert werden konnte.

'''PE''' ('''P'''arity '''E'''rror''')
:Dieses Bit wird vom AVR gesetzt, wenn das im Empfangsdatenregister bereit liegende Zeichen eine Paritätsfehler aufweist.
:Das Bit wird automatisch gelöscht, wenn das empfangene Zeichen in das Empfangsdatenregister transferiert werden konnte.

'''U2X''' (Double the transmission speed)
:Dieses Bit wird lediglich im asynchronen Modus genutzt. Im synchronen Modus ist es 0 zu setzen. Wird das Bit gesetzt, so wird der Baudraten Divisor von 16 auf 8 reduziert, was einer Verdopplung der Transferrate gleich kommt.

'''MPCM''' ('''M'''ulti '''P'''rozessor '''C'''ommunication '''M'''ode)
:Dieses Bit aktiviert die Multi-Prozessor-Kommunikation. Jeder eintreffende Frame der keine Adressinformation enthält wird dadurch ignoriert.

|-
| '''UCSRB    '''
| '''U'''ART '''C'''ontrol and '''S'''tatus '''R'''egister '''B'''. 
In diesem Register stellen wir ein, wie wir den UART verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''RXCIE'''|| '''TXCIE'''|| '''UDRIE'''|| '''RXEN'''|| '''TXEN'''|| '''UCSZ2'''|| '''RXB8'''|| '''TXB8'''
|-
! R/W
| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R|| R/W
|-
! Initialwert
| 0|| 0|| 0|| 0|| 0|| 0|| 0|| 0
|}

'''RXCIE''' ('''RX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART RX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART empfangen wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TXCIE''' ('''TX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART TX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART gesendet wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''UDRIE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART Datenregister Leer Interrupt ausgelöst, wenn der UART wieder bereit ist um ein neues zu sendendes Zeichen zu übernehmen. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''RXEN''' ('''R'''eceiver '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Empfänger des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''TXEN''' ('''T'''ransmitter '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Sender des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''UCSZ2''' (Characters Size)
:Dieses Bit setzt in Verbindung mit dem UCSZ1:0 Bits im UCSRC Register die Anzahl von Datenbits eines Frames beim Empfang oder Senden.

'''RXB8''' (Receive Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann enthält dieses Bit das 9. Datenbit eines empfangenen Zeichens.

'''TXB8''' (Transmit Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann muss in dieses Bit das 9. Bit des zu sendenden Zeichens eingeschrieben werden bevor das eigentliche Datenbyte in das Datenregister geschrieben wird.
|-
| '''UCSRC    '''
| '''U'''ART '''C'''ontrol and '''S'''tatus '''R'''egister '''C'''. 

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''URSEL'''|| '''UMSEL'''|| '''UPM1'''|| '''UPM0'''|| '''USBS'''|| '''UCSZ1'''|| '''UCSZ0'''|| '''UCPOL'''
|-
! R/W
| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R/W
|-
! Initialwert
| 1|| 0|| 0|| 0|| 0|| 1|| 1|| 0
|}

'''URSEL''' (Register Select)
:Dieses Bit selektiert die Auswahl des UCSRC- bzw. des UBRRH Registers. Beim Lesen von UCSRC wird es als 1 gelesen. Beim Schreiben auf UCSRC muss es auf 1 gesetzt werden.

:Achtung: Manche Prozessoren verfügen über dieses Bit, andere wiederrum nicht. Was hat es damit auf sich? Um Zugriffsadressen einzusparen, wurde von Atmel ein etwas seltsamer Weg gewählt. Das UCSRC Register und das High-Byte des Baudratenregisters teilen sich dieselbe Registeradresse! Um der Hardware mitzuteilen, welche Bedeutung ein zugewiesener Wert haben soll, entweder neue Belegung des Baudratenregisters oder eben Konfiguration des UCSRC Registers, dient dieses Bit. Ist es nicht gesetzt, dann wird eine Zuweisung immer als Zuweisung an das High-Byte des Baudratenregisters angesehen, selbst wenn das so nicht beabsichtigt war. Nur dann wenn dieses Bit gesetzt ist, dann wird eine Zuweisung auch tatsächlich als eine Zuweisung an das UCSRC Register gewertet und die Konfiguration verändert. Lässt man das Bit irrtümlich weg, dann verursacht eine Zuweisung an UCSRC eine Veränderung der Baudrateneinstellung!

'''UMSEL''' (USART Mode Select)
:Durch dieses Bit kann eine asynchrone oder synchrone Übertragung eingestellt werden. Durch Setzen des Bits wird eine synchrone Übertragung eingestellt.

'''UPM1:0''' (Parity Mode)
{| class="wikitable" style="text-align:center"
|-
| '''UPM1'''|| '''UPM0'''|| '''Parity Mode'''
|-
| 0|| 0|| Disabled
|-
| 0|| 1|| Reserved
|-
| 1|| 0|| Enabled, Even Priority
|-
| 1|| 1|| Enabled, OddPriority
|}

'''USBS''' ('''U'''SART '''S'''top '''B'''it '''S'''elect)
:Diese Bits setzen die Anzahl der zu sendenden Stopbits eines Frames. Beim Setzen werden 2 Stopbits übertragen, andernfalls nur 1 Stopbit.
{| class="wikitable" style="text-align:center"
|-
| '''USBS'''|| '''Anzahl der Stop Bits'''
|-
| 0|| 1
|-
| 1|| 2

|}

'''UCSZ1:0''' (Character Size)
:Diese Bits setzen in Verbindung mit UCSZ2 aus dem UCSRB Register die Anzahl der Datenbits eines Frames.
:Diese Bits setzen den entsprechenden Paritätsmodus.
{| class="wikitable" style="text-align:center"
|-
| '''UCSZ2'''|| '''UCSZ1'''|| '''UCSZ0'''|| '''Character Size'''
|-
| 0|| 0|| 0|| 5-Bit
|-
| 0|| 0|| 1|| 6-Bit
|-
| 0|| 1|| 0|| 7-Bit
|-
| 0|| 1|| 1|| 8-Bit
|-
| 1|| 0|| 0|| Reserved
|-
| 1|| 0|| 1|| Reserved
|-
| 1|| 1|| 0|| Reserved
|-
| 1|| 1|| 1|| 9-Bit
|}

'''UCPOL''' (Clock Polarity)

|-
| '''UDR'''
| '''U'''ART '''D'''ata '''R'''egister. 
Hier werden Daten zwischen UART und CPU übertragen. Da der UART im
Vollduplexbetrieb gleichzeitig empfangen und senden kann, handelt es sich
hier physikalisch um 2 Register, die aber über die gleiche I/O-Adresse
angesprochen werden. Je nachdem, ob ein Lese- oder ein Schreibzugriff auf
den UART erfolgt wird automatisch das richtige UDR angesprochen.
|-
| '''UBRR'''
| '''U'''ART '''B'''aud '''R'''ate '''R'''egister. 
In diesem Register müssen wir dem UART mitteilen, wie schnell wir gerne kommunizieren möchten. Der Wert, der in dieses Register geschrieben werden muss, errechnet sich nach folgender Formel (wenn U2X Bit 0 gesetzt ist):

:<math>
\mathrm{UBRR} = \frac{\mathrm{Taktfrequenz}}{\mathrm{Baudrate} \cdot 16} - 1
</math>

Es sind Baudraten bis über 115200 Baud möglich, je nach Controller und CPU-Frequenz. Siehe Datenblatt.
|}

== UART initialisieren ==

Wir wollen nun Daten mit dem UART auf die serielle Schnittstelle ausgeben. Dazu müssen wir den UART zuerst mal initialisieren. Dazu setzen wir je nach gewünschter Funktionsweise die benötigten Bits im '''U'''ART '''C'''ontrol '''R'''egister.

Da wir vorerst nur senden möchten und noch keine Interrupts auswerten wollen, gestaltet sich die Initialisierung wirklich sehr einfach, da wir lediglich das '''Transmitter Enable''' Bit setzen müssen:

<c>
UCSRB |= (1<<TXEN);
</c>

Neuere AVRs mit USART haben mehrere Konfigurationsregister und erfordern eine etwas andere Konfiguration. Für einen ATmega16 z. B.:

<c>
UCSRB |= (1<<TXEN); // UART TX einschalten
UCSRC = (1<<URSEL)|(1 << UCSZ1)|(1 << UCSZ0); // Asynchron 8N1
</c>

Nun ist noch das Baudratenregister '''UBRR''' der verwendeten UARTs einzustellen, bzw. bei neueren AVRs die beiden Register '''UBRRL''' und '''UBRRH'''. . Die Berechnung wird während des Compilerlaufs ausgeführt, beansprucht also in der gezeigten Form weder Speicher noch Rechenzeit des Controllers. Das Ergebniss wird jedoch als ganzzahliger Wert eingesetzt, d.h. Nachkommastellen werden einfach abgeschnitten und es erfolgt keine Rundund. Aus diesem Grund kann man sich eines kleinen Tricks bedienen, indem vor der eigentlichen Division bei der Zuweisung die Hälfte des Wertes dazu addiert wird. Allgemein formuliert bedeutet das: <code>int i = ( a + b/2 ) / b;</code>. Dies wird in der unten angegebenen Berechnung von UBRR_VAL ausgenutzt um den Fehler zu minimieren. (Eine ausführliche Erklärung zum ''cleveren Runden'' findet sich in einer [http://www.mikrocontroller.net/topic/170617#1631916 Forumsdiskussion].)

<c>
/*
UART-Init:
Berechnung des Wertes für das Baudratenregister
aus Taktrate und gewünschter Baudrate
*/

#ifndef F_CPU
/* In neueren Version der WinAVR/Mfile Makefile-Vorlage kann
F_CPU im Makefile definiert werden, eine nochmalige Definition
hier wuerde zu einer Compilerwarnung fuehren. Daher "Schutz" durch
#ifndef/#endif

Dieser "Schutz" kann zu Debugsessions führen, wenn AVRStudio
verwendet wird und dort eine andere, nicht zur Hardware passende
Taktrate eingestellt ist: Dann wird die folgende Definition
nicht verwendet, sondern stattdessen der Defaultwert (8 MHz?)
von AVRStudio - daher Ausgabe einer Warnung falls F_CPU
noch nicht definiert: */
#warning "F_CPU war noch nicht definiert, wird nun nachgeholt mit 4000000"
#define F_CPU 4000000UL // Systemtakt in Hz - Definition als unsigned long beachten
// Ohne ergeben sich unten Fehler in der Berechnung
#endif

#define BAUD 9600UL // Baudrate

// Berechnungen
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1) // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1))) // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.

#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
#error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!
#endif
</c>

Die Makros sind sehr praktisch, da damit sowohl automatisch der Wert für UBRR, als auch die Abweichung in der generierten (möglichen) von der gewünschten Baudrate berechnet wird. Im Falle einer zu hohen Abweichung (+/-1%) wird eine Fehlermeldung ausgegeben und der Compilerablauf abgebrochen. Damit können viele Probleme mit "UART sendet komische Zeichen" vermieden werden. Ausserdem kann man mühelos die Einstellung an eine neue Taktfrequenz bzw. Baudrate anpassen, ohne selber rechnen oder in Tabellen nachschlagen zu müssen.

Die eigentliche Initialisierung der UART Register kann im Hauptprogramm main() vorgenommen werden. Öfters wird jedoch eine Funktion z. B. uart_init() dafür geschrieben, die in der eigenen Codesammlung in mehreren Projekten verwendet werden kann.

Für einige AVR (z. B. ATmega169, ATmega48/88/168, AT90CAN jedoch nicht für z. B. ATmega16/32, ATmega128, ATtiny2313) wird durch die Registerdefinitionen der avr-libc (io*.h) auch für Controller mit zwei UBRR-Registern (UBRRL/UBRRH) ein UBRR bzw. UBRR0 als "16-bit-Register" definiert und man kann den Wert direkt per UBRR = UBRR_VAL zuweisen. Intern werden dann zwei Zuweisungen für UBRRH und UBRRL generiert.

<c>
/* UART-Init Bsp. ATmega48 */

void uart_init(void)
{
UBRR0 = UBRR_VAL;
UCSR0B |= (1<<TXEN0);
// Frame Format: Asynchron 8N1
UCSR0C = (1<<UCSZ01)|(1<<UCSZ00);
}
</c>

Die einzelne Anweisung ist nicht bei allen Controllern möglich, da die beiden Register nicht bei allen aufeinanderfolgende Addressen aufweisen. Die getrennte Zuweisung an UBRRH und UBRRL wie im nächsten Beispiel gezeigt, ist universeller und portabler und daher vorzuziehen. Wichtig ist, dass UBRRH '''vor''' UBRRL geschrieben wird:

<c>
/* UART-Init Bsp. ATmega16 */

void uart_init(void)
{
UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL & 0xFF;

UCSRB |= (1<<TXEN); // UART TX einschalten
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // Asynchron 8N1
}
</c>

Inzwischen gibt es in der avr-libc Makros für obige Berechnung der UBRR Registerwerte aus Taktrate F_CPU und Baudrate BAUD. Dazu wird die Includedatei [http://www.nongnu.org/avr-libc/user-manual/group__util__setbaud.html <util/setbaud.h>] eingebunden, nachdem F_CPU und die gewünschte Baudrate definiert wurden. Einige Beispiele zur Anwendung finden sich in der Dokumentation der avr-libc. Im Quellcode kann dann analog zur oben gezeigten Vorgehensweise einfach das Makro UBRR_VALUE (bzw. UBRRH_VALUE und UBRRL_VALUE) an der entsprechenden Stelle eingesetzt werden. Es wird auch automatisch ermittelt, ob der U2X-Modus (vgl. Datenblatt) zu geringeren Abweichungen führt und dann dem Makro USE_U2X ein Wert ungleich null zugewiesen. Ein Beispiel (angelehnt an die avr-libc-Dokumentation):

<c>
#include <avr/io.h>
#define F_CPU 1000000 /* evtl. bereits via Compilerparameter definiert */
#define BAUD 9600
#include <util/setbaud.h>

void uart_init(void)
{
UBRRH = UBRRH_VALUE;
UBRRL = UBRRL_VALUE;
/* evtl. verkuerzt falls Register aufeinanderfolgen (vgl. Datenblatt)
UBRR = UBRR_VALUE;
*/
#if USE_2X
/* U2X-Modus erforderlich */
UCSRA |= (1 << U2X);
#else
/* U2X-Modus nicht erforderlich */
UCSRA &= ~(1 << U2X);
#endif

// hier weitere Initialisierungen (TX und/oder RX aktivieren, Modus setzen
}
</c>

Siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/group__util__setbaud.html Dokumentation der avr-libc zu <util/setbaud.h>]
* [http://www.wormfood.net/avrbaudcalc.php WormFood's AVR Baud Rate Calculator] online.
* [http://www.gjlay.de/helferlein/avr-uart-rechner.html AVR Baudraten-Rechner] in JavaScript

== Senden mit dem UART ==

=== Senden einzelner Zeichen ===

Um nun ein Zeichen auf die Schnittstelle auszugeben, müssen wir dasselbe
lediglich in das '''U'''ART '''D'''ata '''R'''egister schreiben. Vorher ist zu prüfen, ob das UART-Modul bereit ist, das zu sendende Zeichen entgegenzunehmen. Die Bezeichnungen des/der Statusregisters mit dem Bit UDRE ist abhängig vom Controllertypen (vgl. Datenblatt).

<c>
// bei neueren AVRs steht der Status in UCSRA/UCSR0A/UCSR1A, hier z. B. fuer ATmega16:
while (!(UCSRA & (1<<UDRE))) /* warten bis Senden moeglich */
{
}

UDR = 'x'; /* schreibt das Zeichen x auf die Schnittstelle */
</c>

=== Schreiben einer Zeichenkette (String) ===

Die Aufgabe "String senden" wird durch zwei Funktionen abgearbeitet. Die universelle/controllerunabhängige Funktion uart_puts übergibt jeweils ein Zeichen der Zeichenkette an eine Funktion uart_putc, die abhängig von der vorhandenen Hardware implementiert werden muss. In der Funktion zum Senden eines Zeichens ist darauf zu achten, dass vor dem Senden geprüft wird, ob der UART bereit ist den "Sendeauftrag" entgegenzunehmen.

<c>
/* ATmega16 */
int uart_putc(unsigned char c)
{
while (!(UCSRA & (1<<UDRE))) /* warten bis Senden moeglich */
{
}

UDR = c; /* sende Zeichen */
return 0;
}

/* puts ist unabhaengig vom Controllertyp */
void uart_puts (char *s)
{
while (*s)
{ /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
uart_putc(*s);
s++;
}
}
</c>

Die in uart_putc verwendeten Schleifen, in denen gewartet wird bis die UART-Hardware zum senden bereit ist, sind insofern etwas kritisch, da während des Sendens eines Strings nicht mehr auf andere Ereignisse reagiert werden kann. Universeller ist die Nutzung von FIFO(first-in first-out)-Puffern, in denen die zu sendenden bzw. empfangenen Zeichen/Bytes zwischengespeichert und in Interruptroutinen an die U(S)ART-Hardware weitergegeben bzw. von ihr ausgelesen werden. Dazu existieren fertige Komponenten (Bibliotheken, Libraries), die man recht einfach in eigene Entwicklungen integrieren kann. Es empfiehlt sich, diese Komponenten zu nutzen und das Rad nicht neu zu erfinden.

=== Schreiben von Variableninhalten ===

Sollen Inhalte von Variablen (Ganzzahlen, Gleitkomma) in "menschenlesbarer" Form gesendet werden, ist vor dem Transfer eine Umwandlung in Zeichen ("ASCII") erforderlich. Bei nur einer Ziffer ist diese Umwandlung relativ einfach: man addiert den ASCII-Wert von Null zur Ziffer und kann diesen Wert direkt senden.

<c>
#include <avr/io.h>
#include <stdlib.h>
//...

// hier uart_putc (s.o.)

int main (void)
{
// Ausgabe von 0123456789
char c;

uart_init();

for (uint8_t i=0; i<=9; ++i) {
c = i + '0';
uart_putc( c );
// verkuerzt: uart_putc( i + '0' );
}

while (1) {
;
}

return 0; // never reached

}
</c>

Soll mehr als eine Ziffer ausgegeben werden, bedient man sich zweckmäßigerweise vorhandener Funktionen zur Umwandlung von Zahlen in Zeichenketten/Strings. Die Funktion der avr-libc zur Umwandlung von vorzeichenbehafteten 16bit-Ganzzahlen (int16_t) in Zeichenketten heißt ''itoa'' (Integer to ASCII). Man muss der Funktion einen Speicherbereich zur Verarbeitung (buffer) mit Platz für alle Ziffern, das String-Endezeichen ('\0') und evtl. das Vorzeichen bereitstellen.

<c>
#include <avr/io.h>
#include <stdlib.h>

//...

// hier uart_init, uart_putc, uart_puts (s.o.)

int main(void)
{
char s[7];
int16_t i = -12345;

uart_init();

itoa( i, s, 10 ); // 10 fuer radix -> Dezimalsystem
uart_puts( s );

// da itoa einen Zeiger auf den Beginn von s zurueckgibt verkuerzt auch:
uart_puts( itoa( i, s, 10 ) );

while (1) {
;
}

return 0; // never reached
}
</c>

Für vorzeichenlose 16bit-Ganzzahlen (uint16_t) exisitert ''utoa''. Die Funktionen für 32bit-Ganzzahlen (int32_t und uint32_t) heißen ''ltoa'' bzw. ''ultoa''. Da 32bit-Ganzzahlen mehr Stellen aufweisen können, ist ein entsprechend größerer Pufferspeicher vorzusehen.

Auch Gleitkommazahlen (float/double) können mit bereits vorhandenen Funktionen in Zeichenfolgen umgewandelt werden, dazu existieren die Funktionen ''dtostre'' und ''dtostrf''. dtostre nutzt Exponentialschreibweise ("engineering"-Format). (Hinweis: z.Zt. existiert im avr-gcc kein "echtes" double, intern wird immer mit "einfacher Genauigkeit", entsprechend float, gerechnet.)

dtostrf und dtostre benötigen die libm.a der avr-libc. Bei Nutzung von Makefiles ist der Parameter -lm in in LDFLAGS anzugeben (Standard in den WinAVR/mfile-Makefilevorlagen). Nutzt man AVRStudio als IDE für den GNU-Compiler (gcc-Plugin) ist die libm.a unter Libaries auszuwählen: Project -> Configurations Options -> Libaries -> libm.a mit dem Pfeil nach rechts einbinden. Siehe auch die [[FAQ#Aktivieren_der_Floating_Point_Version_von_sprintf_beim_WinAVR_mit_AVR-Studio|FAQ]]

<c>
#include <avr/io.h>
#include <stdlib.h>

//...

// hier uart_init, uart_putc, uart_puts (s.o.)

/* lt. avr-libc Dokumentation:
char* dtostrf(
double __val,
char __width,
char __prec,
char * __s
)
*/

int main(void)
{
// Pufferspeicher ausreichend groß
// evtl. Vorzeichen + width + Endezeichen:
char s[8];
float f = -12.345;

uart_init();

dtostrf( f, 6, 3, s );
uart_puts( s );
// verkürzt: uart_puts( dtostrf( f, 7, 3, s ) );

while (1) {
;
}

return 0; // never reached
}
</c>

== Empfangen ==
=== Einzelne Zeichen empfangen ===

Zum Empfang von Zeichen muss der Empfangsteil des UART bei der Initialisierung aktiviert werden, indem das RXEN-Bit im jeweiligen Konfigurationsregister (UCSRB bzw UCSR0B/UCSR1B) gesetzt wird. Im einfachsten Fall wird solange gewartet, bis ein Zeichen empfangen wurde, dieses steht dann im UART-Datenregister (UDR bzw. UDR0 und UDR1 bei AVRs mit 2 UARTS) zur Verfügung (sogen. "Polling-Betrieb"). Ein Beispiel für den ATmega16:

<c>
#include <inttypes.h>
#include <avr/io.h>

/* Siehe auch obere Baudrateneinstellung */
/* USART-Init beim ATmega16 */

void uart_init(void)
{
UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL & 0xFF;

UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // Asynchron 8N1
UCSRB |= (1<<RXEN); // UART RX einschalten
}

/* Zeichen empfangen */
uint8_t uart_getc(void)
{
while (!(UCSRA & (1<<RXC))) // warten bis Zeichen verfuegbar
;
return UDR; // Zeichen aus UDR an Aufrufer zurueckgeben
}
</c>

Und die Anwendung in einem Beispiel:

<c>
#include <avr/io.h>
#include <stdlib.h>

// hier Makro für die Baudratenberechnung

// hier uart_init, uart_getc (s.o.)

int main(void)
{
uart_init();
while (1)
{
uint8_t c;
c = uart_getc();

// hier etwas mit c machen z.B. auf PORT ausgeben
DDRC = 0xFF; // PORTC Ausgang
PORTC = c;
}
return 0; // never reached
}
</c>

Die Funktion uart_getc() blockiert allerdings den Programmablauf, denn es wird gewartet, bis ein Zeichen empfangen wird! Möchte man das Warten vermeiden, kann das RXC-Bit in einer Programmschleife abgefragt werden und dann nur bei gesetztem RXC-Bit UDR ausgelesen werden.

<c>
#include <avr/io.h>
#include <stdlib.h>

// hier Makro für die Baudratenberechnung

// hier uart_init, uart_getc (s.o.)

int main(void)
{
uart_init();
while (1)
{
if ( (UCSRA & (1<<RXC)) )
{
// Zeichen wurde empfangen, jetzt abholen
uint8_t c;
c = uart_getc();
// hier etwas mit c machen z.B. auf PORT ausgeben
DDRC = 0xFF; // PORTC Ausgang
PORTC = c;
}
else
{
// Kein Zeichen empfangen, Restprogramm ausführen...
}
}
return 0; // never reached
}
</c>

Eleganter und in den meisten Anwendungsfällen "stabiler" ist die Vorgehensweise, die empfangenen Zeichen in einer Interrupt-Routine einzulesen und zur späteren Verarbeitung in einem Eingangsbuffer (FIFO-Buffer) zwischenzuspeichern. Dazu existieren fertige und gut getestete [[Libraries|Bibliotheken]]  und Quellcodekomponenten (z. B. UART-Library von P. Fleury, procyon-avrlib und einige in der "Academy" von avrfreaks.net).

Siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/group__avr__stdlib.html Dokumenation der avr-libc/stdlib.h]
* [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Die_Nutzung_von_sprintf_und_printf Die Nutzung von sprintf und printf]
* [http://homepage.hispeed.ch/peterfleury/ Peter Fleurys] UART-Bibiliothek fuer avr-gcc/avr-libc


TODO: 9bit

=== Empfang von Zeichenketten (Strings) ===

Beim Empfang von Zeichenketten, muß man sich zunächst darüber im klaren sein, daß es ein Kriterium geben muß, an dem der µC erkennen kann, wann ein Text zu Ende ist. Sehr oft wird dazu das Zeichen 'Return' benutzt, um das Ende eines Textes zu markieren. Dies ist vom Benutzer einfach eingebbar und er ist auch daran gewöhnt, daß er eine Eingabezeile mit einem Druck auf die Return Taste abgeschlossen wird.

Prinzipiell gibt es jedoch keine Einschränkung bezüglich dieses speziellen Zeichens. Es muß nur sichergestellt werden, daß dieses spezielle 'Ende eines Strings' - Zeichen nicht mit einem im Text vorkommenden Zeichen verwechselt werden kann. Wenn also im zu übertragenden Text beispielsweise kein ';' vorkommt, dann spricht nichts dagegen, den Benutzer die Eingabe eines Textes mit einem ';' abschließen zu lassen.

Im Folgenden wird die durchaus übliche Annahme getroffen, daß eine Stringübertragung identisch ist mit der Übertragung einer Textzeile und daher mit einem Return ('\n') abgeschlossen wird.

Das Problem der Übertragung eines Strings reduziert sich damit auf die Aufgabenstellung: Empfange und sammle Zeichen in einem char Array, bis entweder das Array voll ist oder das Text Ende Zeichen' empfangen wurde. Danach wird der empfangene Text noch mit einem '\0' Zeichen abgeschlossen um einen Standard C-String daraus zu machen, mit dem dann weiter gearbeitet werden kann.

<C>
/* Zeichen empfangen */
uint8_t uart_getc(void)
{
while (!(UCSRA & (1<<RXC))) // warten bis Zeichen verfuegbar
;
return UDR; // Zeichen aus UDR an Aufrufer zurueckgeben
}

void uart_gets( char* Buffer, uint8_t MaxLen )
{
uint8_t NextChar;
uint8_t StringLen = 0;

NextChar = uart_getc(); // Warte auf und empfange das nächste Zeichen

// Sammle solange Zeichen, bis:
// * entweder das String Ende Zeichen kam
// * oder das aufnehmende Array voll ist
while( NextChar != '\n' && StringLen < MaxLen - 1 ) {
*Buffer++ = NextChar;
StringLen++;
NextChar = uart_getc();
}

// Noch ein '\0' anhängen um einen Standard
// C-String daraus zu machen
*Buffer = '\0';
}
</C>

Beim Aufruf ist darauf zu achten, dass das empfangende Array auch mit einer
vernünftigen Größe definiert wird.

<C>

char Line[40]; // String mit maximal 39 zeichen

uart_gets( Line, sizeof( Line ) );
</C>

Bei der Benutzung von sizeof() ist allerdings zu beachten, dass sizeof() nicht die Anzahl der Elemente des Arrays liefert, sondern die Länge in Byte. Da ein char nur ein Byte lang ist, passt der Aufruf 'uart_gets(Line, sizeof( Line ) );' in diesem Fall. Falls man - aus welchen Gründen auch immer - andere Datentypen benutzen möchte, sollte man zur korrekten Angabe der Array-Länge folgende Vorgehensweise bevorzugen:

<C>
int Line[40]; // Array vom Typ int

uart_gets( Line, sizeof( Line ) / sizeof( Line[0] ) );
</C>

==Interruptbetrieb==

Hier wird das Grundwissen des Artikels [[Interrupt]] und des Abschnitts [[AVR-GCC-Tutorial#Programmieren_mit_Interrupts|AVR-GCC-Tutorial: Programmieren_mit_Interrupts]] vorausgesetzt.

=== Empfangen (RX) ===

Beim ATmega8 muss das '''RXCIE''' Bit im Register UCSRB gesetzt werden, damit ein Interrupt beim Empfang eines Zeichens ausgelöst werden kann.

<c>
/* siehe auch obere Baudrateneinstellung */
/* USART-Init beim ATmega16 */
void uart_init(void)
{
UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL & 0xFF;
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // Asynchron 8N1
UCSRB |= (1<<RXEN)|(1<<TXEN)|(1<<RXCIE); // UART RX, TX und RX Interrupt einschalten
}
</c>

Natürlich muss "Global Interrupt Enable" mittels des Befehls sei() aktiviert sein. Interrupt-spezifische Definitionen werden über die Includedatei eingebunden:

<c>
#include <avr/interrupt.h>
</c>

Der Interrupt wird immer ausgelöst, wenn ein Zeichen erfolgreich empfangen wurde. Zusätzlich braucht man die Interruptserviceroutine (ISR).

In diesem Beispiel enthält die ISR einen FIFO-Puffer (First in, First out). Dafür werden ein paar globale Variablen und Makros benötigt:

<c>
#define UART_MAXSTRLEN 10

volatile uint8_t uart_str_complete = 0; // 1 .. String komplett empfangen
volatile uint8_t uart_str_count = 0;
volatile char uart_string[UART_MAXSTRLEN + 1] = "";
</c>

<c>
ISR(USART_RXC_vect)
{
unsigned char nextChar;

// Daten aus dem Puffer lesen
nextChar = UDR;
if( uart_str_complete == 0 ) { // wenn uart_string gerade in Verwendung, neues Zeichen verwerfen

// Daten werden erst in uart_string geschrieben, wenn nicht String-Ende/max Zeichenlänge erreicht ist/string gerade verarbeitet wird
if( nextChar != '\n' &&
nextChar != '\r' &&
uart_str_count < UART_MAXSTRLEN - 1 ) {
uart_string[uart_str_count] = nextChar;
uart_str_count++;
}
else {
uart_string[uart_str_count] = '\0';
uart_str_count = 0;
uart_str_complete = 1;
}
}
}
</c>

Zur Funktion: Wurde eine komplette Zeichenkette empfangen, also das Ende (\n oder \r) erkannt oder die maximale Länge ''UART_MAXSTRLEN'' erreicht, wird die globale Variable ''uart_str_complete'' auf '1' gesetzt. Damit wird dem Hauptprogramm, welches auf diese Variable pollt, mitgeteilt, dass die Zeichenkette ''uart_string'' zur Verarbeitung bereit steht. Nach der Verarbeitung der Zeichenkette in der entsprechenden main-Routine, muss die Variable ''uart_str_complete'' wieder auf '0' zurück gesetzt werden. Dadurch werden alle neu empfangenen Zeichen wieder in den globalen Puffer geschrieben.

=== (Baustelle) ===

* Empfangen (Receive) (Anm.: z.T. erledigt)
** ggf. Fallstricke ([http://www.mikrocontroller.net/topic/84256#707214 UDR in der ISR lesen!])
** Komplettes, einfaches Beispiel ([http://www.mikrocontroller.net/topic/84228#707052 Echo] (noch buggy beim Datenzugriff, siehe Lit. 2+3!)), ggf. LED zur ISR-Empfangsanzeige oder Overflow-Anzeige

* Senden (Transmit)
** Variante "UART Data Register Empty" (UDRE) [http://www.mikrocontroller.net/topic/101472#882716]
** Variante "UART Transmit Complete" (TXC)

* FIFO-Puffer [http://www.mikrocontroller.net/topic/101472#882716], Ringpuffer (Byte Buffering (circular))

* UART-Bibliotheken
** [http://homepage.hispeed.ch/peterfleury/avr-software.html UART-Library] von Peter Fleury (UART (interrupt driven), Byte Buffering (circular))
** [http://www.procyonengineering.com/embedded/avr/avrlib/ Procyon AVRlib] von Pascal Stang (UART (interrupt driven), Byte Buffering (circular), VT100 Terminal Output)

* Literatur
** [http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=48188 avrfreaks.net Tutorial] inkl. Diskussion (engl.)
** avr-libc FAQ: [http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_16bitio Why do some 16-bit timer registers sometimes get trashed?]

==Software-UART==

Falls die Zahl der vorhandenen Hardware-UARTs nicht ausreicht, können weitere Schnittstellen über sogennante Software-UARTs ergänzt werden. Es gibt dazu (mindestens) zwei Ansätze:
* Der bei AVRs üblichste Ansatz basiert auf dem Prinzip, dass ein externer Interrupt-Pin für den Empfang ("RX") genutzt wird. Das Startbit löst den Interrupt aus, in der Interrupt-Routine (ISR) wird der externe Interrupt deaktiviert und ein Timer aktiviert. In der Interrupt-Routine des Timers wird der Zustand des Empfangs-Pins entsprechend der Baudrate abgetastet. Nach Empfang des Stop-Bits wird der externe Interrupt wieder aktiviert. Senden kann über einen beliebigen Pin ("TX") erfolgen, der entsprechend der Baudrate und dem zu sendenden Zeichen auf 0 oder 1 gesetzt wird. Die Implementierung ist nicht ganz einfach, es existieren dazu aber fertige Bibliotheken (z. B. bei [http://www.avrfreaks.net/ avrfreaks] oder in der [http://www.procyonengineering.com/embedded/avr/avrlib/ Procyon avrlib]).
* Ein weiterer Ansatz erfordert keinen Pin mit "Interrupt-Funktion" aber benötigt mehr Rechenzeit. Jeder Input-Pin kann als Empfangspin (RX) dienen. Über einen Timer wird der Zustand des RX-Pins mit einem vielfachen der Baudrate abgetastet (dreifach scheint üblich) und High- bzw. Lowbits anhand einer Mindestanzahl identifiziert. (Beispiel: "Generic Software Uart" Application-Note von IAR)

Neuere AVRs (z. B. ATtiny26 oder ATmega48,88,168,169) verfügen über ein Universal Serial Interface (USI), das teilweise UART-Funktion übernehmen kann. Atmel stellt eine Application-Note bereit, in der die Nutzung des USI als UART erläutert wird (im Prinzip "Hardware-unterstützter Software-UART").

==Handshaking==
Wenn der Sender ständig sendet, wird irgendwann der Fall eintreten, daß der Empfänger nicht bereit ist, neue Zeichen zu empfangen. In diesem Fall muß durch ein '''Handshake-Verfahren''' die Situation bereinigt werden. Handshake bedeutet nichts anderes, als daß der Empfänger dem Sender mitteilt, daß er zur Zeit keine Daten annehmen kann und der Sender die Übertragung der nächsten Zeichen solange einstellen soll, bis der Empfänger signalisiert, daß er wieder Zeichen aufnehmen kann.
===Hardwarehandshake (RTS/CTS)===
Beim Hardwarehandshake werden zusätzlich zu den beiden Daten-Übertragungsleitungen noch 2 weitere Leitungen benötigt: '''RTS''' ('''R'''equest '''T'''o '''S'''end) und '''CTS''' ('''C'''lear '''T'''o '''S'''end). Jeder der beiden Kommunikationspartner ist verpflichtet, bevor ein Zeichen gesendet wird, den Zustand der '''RTS''' Leitung zu überprüfen. Nur wenn die Gegenstelle darauf Empfangsbereitschaft signalisiert, darf das Zeichen gesendet werden. Um der Gegenstelle zu signalisieren, daß sie zur Zeit keine Zeichen schicken soll, wird die Leitung '''CTS''' benutzt.

===Softwarehandshake (XON/XOFF)===
Beim Softwarehandshake sind keine speziellen Leitungen notwendig. Statt dessen werden besondere ASCII-Zeichen benutzt, die der Gegenstelle signalisieren, daß Senden einzustellen bzw. wieder aufzunehmen. 
* '''XOFF''' Aufforderung das Senden einzustellen
* '''XON''' Gegenstelle darf wieder senden

Nachteilig bei einem Softwarehandshake ist es, dass dadurch keine direkte binäre Datenübertragung mehr möglich ist. Von den möglichen 256 Bytewerten werden ja 2 (nämlich '''XON''' und '''XOFF''') für besondere Zwecke benutzt und fallen daher aus.

==Galvanische Trennung==
Für eine geringe Überspannungsfestigkeit empfielt es sich, die Datenkanäle über Optokoppler zu führen. Es bietet sich z.b. der 6N138 an, ein "normaler" CNY-17 ist für hohe Baudraten nicht brauchbar.

==Fehlersuche==
Erstaunlich oft wird im Forum der Hilferuf laut: "Meine UART funktioniert nicht, was mache ich falsch". In der überwiegenden Mehrzahl der Fälle stellt sich dann heraus, daß es sich um ein Hardwareproblem handelt, wobei da wiederrum der Löwenanteil auf das Konto einer nicht korrekt eingestellten Taktrate geht: Der µC benutzt nicht einen angeschlossenen Quarz, so wie er auch im Programm eingetragen ist, sondern läuft immer noch mit dem internen RC-Takt. Daraus resultiert aber auch, daß der Baudraten Konfigurationswert falsch berechnet wird.

Hilfreich zum Aufspüren solcher Fehler ist auch die [[AVR_Checkliste#UART/USART|AVR-Checkliste]].

==Links==
Tipps zur Verarbeitung von Strings sind in den [[FAQ]].

[[Kategorie:avr-gcc Tutorial]]
[[Kategorie:UART und RS232]]

AVR-GCC-Tutorial/Der UART

2011-07-27T10:00:41Z

145.225.60.4: /* Einzelne Zeichen empfangen */

Über den [[UART]] kann ein [[AVR]] leicht mit einer [[RS-232]]-Schnittstelle eines PC oder sonstiger Geräte mit "[[seriell]]er Schnittstelle" verbunden werden.

== Allgemeines zum UART ==

Mögliche Anwendungen des UART:

;Debug-Schnittstelle: z. B. zur Anzeige von Zwischenergebnissen ("printf-debugging" - hier besser "Logging" oder "UART-debugging") über [[RS-232]] auf einem PC. Auf dem Rechner reicht dazu ein [[RS-232#Terminalprogramme|Terminalprogramm]] (MS-Windows: Hyperterm oder besser [https://sites.google.com/site/terminalbpp/], [http://www.der-hammer.info/terminal/ HTerm]; Unix/Linux z. B. minicom). Ein direkter Anschluss ist aufgrund unterschiedlicher Pegel nicht möglich, jedoch sind entsprechende Schnittstellen-ICs wie z. B. ein MAX232 günstig und leicht zu integrieren. Rechner ohne serielle Schnittstelle können über fertige USB-seriell-Adapter angeschlossen werden.
;Mensch-Maschine Schnittstelle: z. B. Konfiguration und Statusabfrage über eine "Kommandozeile" oder Menüs (siehe z. B. Forumsbeitrag [http://www.mikrocontroller.net/topic/52985 Auswertung RS232-Befehle] und Artikel [[Tinykon]])
;Übertragen von gespeicherten Werten: z. B. bei einem Datenlogger
;Anschluss von Geräten: mit serieller Schnittstelle (z. B. (Funk-)Modems, Mobiltelefone, Drucker, Sensoren, "intelligente" LC-Displays, GPS-Empfänger).
;"Feldbusse": auf RS485/RS422-Basis mittels entsprechenden Bustreiberbausteinen (z. B. MAX485)
;DMX, Midi: etc.
;LIN-Bus: '''L'''ocal '''I'''nterconnect '''N'''etwork: Preiswerte Sensoren/Aktoren in der Automobiltechnik und darüber hinaus

Einige AVR-Controller haben ein bis zwei vollduplexfähige UART ('''U'''niversal '''A'''synchronous '''R'''eceiver and '''T'''ransmitter) schon eingebaut ("Hardware-UART").
Übrigens: Vollduplex heißt nichts anderes, als dass der Baustein gleichzeitig senden und empfangen kann.

Neuere AVRs (ATmega, ATtiny) verfügen über einen bis vier U'''S'''ART(s), dieser unterscheidet sich vom UART hauptsächlich durch interne FIFO-Puffer für Ein- und Ausgabe und erweiterte Konfigurationsmöglichkeiten. Die Puffergröße ist allerdings nur 1 Byte.

== Die Hardware ==

Der UART basiert auf normalem TTL-Pegel mit 0V (logisch 0) und 5V (logisch 1). Die Schnittstellenspezifikation für RS-232 definiert jedoch -3V ... -12V (logisch 1) und
+3 ... +12V (logisch 0). Daher muss der Signalaustausch zwischen AVR und Partnergerät invertiert werden. Für die Anpassung der Pegel und das Invertieren der Signale gibt es fertige Schnittstellenbausteine. Der bekannteste davon ist wohl der MAX232.


Streikt die Kommunikation per UART, so ist oft eine fehlerhafte Einstellung der Baudrate die Ursache. Die Konfiguration auf eine bestimmte Baudrate ist abhängig von der Taktfrequenz des Controllers. Gerade bei neu aufgebauten Schaltungen (bzw. neu gekauften Controllern) sollte man sich daher noch einmal vergewissern, dass der Controller auch tatsächlich mit der vermuteten Taktrate arbeitet und nicht z. B. den bei einigen Modellen werksseitig eingestellten internen [[Oszillator]] statt eines externen Quarzes nutzt. Die Werte der verschiedenen fuse-bits im Fehlerfall also beispielsweise mit ''[[AVRDUDE]]'' kontrollieren und falls nötig anpassen. Grundsätzlich empfiehlt sich auch immer ein Blick in die [[AVR_Checkliste]].

== Die UART-Register ==

Der UART wird über vier separate Register angesprochen. Die USARTs der ATMEGAs verfügen über mehrere zusätzliche Konfigurationsregister. Das Datenblatt gibt darüber Auskunft. Die folgende Tabelle gibt nur die Register für die UARTs der ATmega8/16/32 u.ä. wieder.

{| class="wikitable"
|-
| '''UCSRA   '''
| '''U'''ART '''C'''ontrol and '''S'''tatus '''R'''egister '''A'''. 
Hier teilt uns der UART mit, was er gerade so macht.

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''RXC'''|| '''TXC'''|| '''UDRE'''|| '''FE'''|| '''DOR'''|| '''PE'''|| '''U2X'''|| '''MPCM'''
|-
! R/W
| R|| R/W|| R|| R|| R|| R|| R/W|| R/W
|-
! Initialwert
| 0|| 0|| 1|| 0|| 0|| 0|| 0|| 0
|}

'''RXC''' (UART Receive Complete)
:Dieses Bit wird vom AVR gesetzt, wenn ein empfangenes Zeichen vom Empfangs-Schieberegister in das Empfangs-Datenregister transferiert wurde.
:Das Zeichen muss nun schnellstmöglich aus dem Datenregister ausgelesen werden. Falls dies nicht erfolgt, bevor ein weiteres Zeichen komplett empfangen wurde, wird eine Überlauf-Fehlersituation eintreten. Mit dem Auslesen des Datenregisters wird das Bit automatisch gelöscht.

'''TXC''' (UART Transmit Complete)
:Dieses Bit wird vom AVR gesetzt, wenn das im Sende-Schieberegister befindliche Zeichen vollständig ausgegeben wurde und kein weiteres Zeichen im Sendedatenregister ansteht. Dies bedeutet also, dass die Kommunikation vollumfänglich abgeschlossen ist.
:Dieses Bit ist wichtig bei Halbduplex-Verbindungen, wenn das Programm nach dem Senden von Daten auf Empfang schalten muss. Im Vollduplexbetrieb brauchen wir dieses Bit nicht zu beachten.
:Das Bit wird nur dann automatisch gelöscht, wenn der entsprechende Interrupthandler aufgerufen wird, ansonsten müssen wir das Bit selber löschen.

'''UDRE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty)
:Dieses Bit zeigt an, ob der Sendepuffer bereit ist, um ein zu sendendes Zeichen aufzunehmen. Das Bit wird vom AVR gesetzt (1), wenn der Sendepuffer leer ist. Es wird gelöscht (0), wenn ein Zeichen im Sendedatenregister vorhanden ist und noch nicht in das Sende-Schieberegister übernommen wurde. Atmel empfiehlt aus Kompatibilitätsgründen mit kommenden µC, UDRE auf 0 zu setzen, wenn das UCSRA Register beschrieben wird.
:Das Bit wird automatisch gelöscht, wenn ein Zeichen in das Sendedatenregister geschrieben wird.

'''FE''' ('''F'''raming '''E'''rror)
:Dieses Bit wird vom AVR gesetzt, wenn der UART einen Zeichenrahmenfehler detektiert, d.h. wenn das Stopbit eines empfangenen Zeichens 0 ist.
:Das Bit wird automatisch gelöscht, wenn das Stopbit des empfangenen Zeichens 1 ist.

'''DOR''' ('''D'''ata '''O'''ver '''R'''un)
:Dieses Bit wird vom AVR gesetzt, wenn unser Programm das im Empfangsdatenregister bereit liegende Zeichen nicht abholt bevor das nachfolgende Zeichen komplett empfangen wurde.
:Das nachfolgende Zeichen wird verworfen.
:Das Bit wird automatisch gelöscht, wenn das empfangene Zeichen in das Empfangsdatenregister transferiert werden konnte.

'''PE''' ('''P'''arity '''E'''rror''')
:Dieses Bit wird vom AVR gesetzt, wenn das im Empfangsdatenregister bereit liegende Zeichen eine Paritätsfehler aufweist.
:Das Bit wird automatisch gelöscht, wenn das empfangene Zeichen in das Empfangsdatenregister transferiert werden konnte.

'''U2X''' (Double the transmission speed)
:Dieses Bit wird lediglich im asynchronen Modus genutzt. Im synchronen Modus ist es 0 zu setzen. Wird das Bit gesetzt, so wird der Baudraten Divisor von 16 auf 8 reduziert, was einer Verdopplung der Transferrate gleich kommt.

'''MPCM''' ('''M'''ulti '''P'''rozessor '''C'''ommunication '''M'''ode)
:Dieses Bit aktiviert die Multi-Prozessor-Kommunikation. Jeder eintreffende Frame der keine Adressinformation enthält wird dadurch ignoriert.

|-
| '''UCSRB    '''
| '''U'''ART '''C'''ontrol and '''S'''tatus '''R'''egister '''B'''. 
In diesem Register stellen wir ein, wie wir den UART verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''RXCIE'''|| '''TXCIE'''|| '''UDRIE'''|| '''RXEN'''|| '''TXEN'''|| '''UCSZ2'''|| '''RXB8'''|| '''TXB8'''
|-
! R/W
| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R|| R/W
|-
! Initialwert
| 0|| 0|| 0|| 0|| 0|| 0|| 0|| 0
|}

'''RXCIE''' ('''RX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART RX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART empfangen wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TXCIE''' ('''TX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART TX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART gesendet wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''UDRIE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART Datenregister Leer Interrupt ausgelöst, wenn der UART wieder bereit ist um ein neues zu sendendes Zeichen zu übernehmen. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''RXEN''' ('''R'''eceiver '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Empfänger des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''TXEN''' ('''T'''ransmitter '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Sender des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''UCSZ2''' (Characters Size)
:Dieses Bit setzt in Verbindung mit dem UCSZ1:0 Bits im UCSRC Register die Anzahl von Datenbits eines Frames beim Empfang oder Senden.

'''RXB8''' (Receive Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann enthält dieses Bit das 9. Datenbit eines empfangenen Zeichens.

'''TXB8''' (Transmit Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann muss in dieses Bit das 9. Bit des zu sendenden Zeichens eingeschrieben werden bevor das eigentliche Datenbyte in das Datenregister geschrieben wird.
|-
| '''UCSRC    '''
| '''U'''ART '''C'''ontrol and '''S'''tatus '''R'''egister '''C'''. 

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''URSEL'''|| '''UMSEL'''|| '''UPM1'''|| '''UPM0'''|| '''USBS'''|| '''UCSZ1'''|| '''UCSZ0'''|| '''UCPOL'''
|-
! R/W
| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R/W
|-
! Initialwert
| 1|| 0|| 0|| 0|| 0|| 1|| 1|| 0
|}

'''URSEL''' (Register Select)
:Dieses Bit selektiert die Auswahl des UCSRC- bzw. des UBRRH Registers. Beim Lesen von UCSRC wird es als 1 gelesen. Beim Schreiben auf UCSRC muss es auf 1 gesetzt werden.

:Achtung: Manche Prozessoren verfügen über dieses Bit, andere wiederrum nicht. Was hat es damit auf sich? Um Zugriffsadressen einzusparen, wurde von Atmel ein etwas seltsamer Weg gewählt. Das UCSRC Register und das High-Byte des Baudratenregisters teilen sich dieselbe Registeradresse! Um der Hardware mitzuteilen, welche Bedeutung ein zugewiesener Wert haben soll, entweder neue Belegung des Baudratenregisters oder eben Konfiguration des UCSRC Registers, dient dieses Bit. Ist es nicht gesetzt, dann wird eine Zuweisung immer als Zuweisung an das High-Byte des Baudratenregisters angesehen, selbst wenn das so nicht beabsichtigt war. Nur dann wenn dieses Bit gesetzt ist, dann wird eine Zuweisung auch tatsächlich als eine Zuweisung an das UCSRC Register gewertet und die Konfiguration verändert. Lässt man das Bit irrtümlich weg, dann verursacht eine Zuweisung an UCSRC eine Veränderung der Baudrateneinstellung!

'''UMSEL''' (USART Mode Select)
:Durch dieses Bit kann eine asynchrone oder synchrone Übertragung eingestellt werden. Durch Setzen des Bits wird eine synchrone Übertragung eingestellt.

'''UPM1:0''' (Parity Mode)
{| class="wikitable" style="text-align:center"
|-
| '''UPM1'''|| '''UPM0'''|| '''Parity Mode'''
|-
| 0|| 0|| Disabled
|-
| 0|| 1|| Reserved
|-
| 1|| 0|| Enabled, Even Priority
|-
| 1|| 1|| Enabled, OddPriority
|}

'''USBS''' ('''U'''SART '''S'''top '''B'''it '''S'''elect)
:Diese Bits setzen die Anzahl der zu sendenden Stopbits eines Frames. Beim Setzen werden 2 Stopbits übertragen, andernfalls nur 1 Stopbit.
{| class="wikitable" style="text-align:center"
|-
| '''USBS'''|| '''Anzahl der Stop Bits'''
|-
| 0|| 1
|-
| 1|| 2

|}

'''UCSZ1:0''' (Character Size)
:Diese Bits setzen in Verbindung mit UCSZ2 aus dem UCSRB Register die Anzahl der Datenbits eines Frames.
:Diese Bits setzen den entsprechenden Paritätsmodus.
{| class="wikitable" style="text-align:center"
|-
| '''UCSZ2'''|| '''UCSZ1'''|| '''UCSZ0'''|| '''Character Size'''
|-
| 0|| 0|| 0|| 5-Bit
|-
| 0|| 0|| 1|| 6-Bit
|-
| 0|| 1|| 0|| 7-Bit
|-
| 0|| 1|| 1|| 8-Bit
|-
| 1|| 0|| 0|| Reserved
|-
| 1|| 0|| 1|| Reserved
|-
| 1|| 1|| 0|| Reserved
|-
| 1|| 1|| 1|| 9-Bit
|}

'''UCPOL''' (Clock Polarity)

|-
| '''UDR'''
| '''U'''ART '''D'''ata '''R'''egister. 
Hier werden Daten zwischen UART und CPU übertragen. Da der UART im
Vollduplexbetrieb gleichzeitig empfangen und senden kann, handelt es sich
hier physikalisch um 2 Register, die aber über die gleiche I/O-Adresse
angesprochen werden. Je nachdem, ob ein Lese- oder ein Schreibzugriff auf
den UART erfolgt wird automatisch das richtige UDR angesprochen.
|-
| '''UBRR'''
| '''U'''ART '''B'''aud '''R'''ate '''R'''egister. 
In diesem Register müssen wir dem UART mitteilen, wie schnell wir gerne kommunizieren möchten. Der Wert, der in dieses Register geschrieben werden muss, errechnet sich nach folgender Formel (wenn U2X Bit 0 gesetzt ist):

:<math>
\mathrm{UBRR} = \frac{\mathrm{Taktfrequenz}}{\mathrm{Baudrate} \cdot 16} - 1
</math>

Es sind Baudraten bis über 115200 Baud möglich, je nach Controller und CPU-Frequenz. Siehe Datenblatt.
|}

== UART initialisieren ==

Wir wollen nun Daten mit dem UART auf die serielle Schnittstelle ausgeben. Dazu müssen wir den UART zuerst mal initialisieren. Dazu setzen wir je nach gewünschter Funktionsweise die benötigten Bits im '''U'''ART '''C'''ontrol '''R'''egister.

Da wir vorerst nur senden möchten und noch keine Interrupts auswerten wollen, gestaltet sich die Initialisierung wirklich sehr einfach, da wir lediglich das '''Transmitter Enable''' Bit setzen müssen:

<c>
UCSRB |= (1<<TXEN);
</c>

Neuere AVRs mit USART haben mehrere Konfigurationsregister und erfordern eine etwas andere Konfiguration. Für einen ATmega16 z. B.:

<c>
UCSRB |= (1<<TXEN); // UART TX einschalten
UCSRC = (1<<URSEL)|(1 << UCSZ1)|(1 << UCSZ0); // Asynchron 8N1
</c>

Nun ist noch das Baudratenregister '''UBRR''' der verwendeten UARTs einzustellen, bzw. bei neueren AVRs die beiden Register '''UBRRL''' und '''UBRRH'''. . Die Berechnung wird während des Compilerlaufs ausgeführt, beansprucht also in der gezeigten Form weder Speicher noch Rechenzeit des Controllers. Das Ergebniss wird jedoch als ganzzahliger Wert eingesetzt, d.h. Nachkommastellen werden einfach abgeschnitten und es erfolgt keine Rundund. Aus diesem Grund kann man sich eines kleinen Tricks bedienen, indem vor der eigentlichen Division bei der Zuweisung die Hälfte des Wertes dazu addiert wird. Allgemein formuliert bedeutet das: <code>int i = ( a + b/2 ) / b;</code>. Dies wird in der unten angegebenen Berechnung von UBRR_VAL ausgenutzt um den Fehler zu minimieren. (Eine ausführliche Erklärung zum ''cleveren Runden'' findet sich in einer [http://www.mikrocontroller.net/topic/170617#1631916 Forumsdiskussion].)

<c>
/*
UART-Init:
Berechnung des Wertes für das Baudratenregister
aus Taktrate und gewünschter Baudrate
*/

#ifndef F_CPU
/* In neueren Version der WinAVR/Mfile Makefile-Vorlage kann
F_CPU im Makefile definiert werden, eine nochmalige Definition
hier wuerde zu einer Compilerwarnung fuehren. Daher "Schutz" durch
#ifndef/#endif

Dieser "Schutz" kann zu Debugsessions führen, wenn AVRStudio
verwendet wird und dort eine andere, nicht zur Hardware passende
Taktrate eingestellt ist: Dann wird die folgende Definition
nicht verwendet, sondern stattdessen der Defaultwert (8 MHz?)
von AVRStudio - daher Ausgabe einer Warnung falls F_CPU
noch nicht definiert: */
#warning "F_CPU war noch nicht definiert, wird nun nachgeholt mit 4000000"
#define F_CPU 4000000UL // Systemtakt in Hz - Definition als unsigned long beachten
// Ohne ergeben sich unten Fehler in der Berechnung
#endif

#define BAUD 9600UL // Baudrate

// Berechnungen
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1) // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1))) // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.

#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
#error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!
#endif
</c>

Die Makros sind sehr praktisch, da damit sowohl automatisch der Wert für UBRR, als auch die Abweichung in der generierten (möglichen) von der gewünschten Baudrate berechnet wird. Im Falle einer zu hohen Abweichung (+/-1%) wird eine Fehlermeldung ausgegeben und der Compilerablauf abgebrochen. Damit können viele Probleme mit "UART sendet komische Zeichen" vermieden werden. Ausserdem kann man mühelos die Einstellung an eine neue Taktfrequenz bzw. Baudrate anpassen, ohne selber rechnen oder in Tabellen nachschlagen zu müssen.

Die eigentliche Initialisierung der UART Register kann im Hauptprogramm main() vorgenommen werden. Öfters wird jedoch eine Funktion z. B. uart_init() dafür geschrieben, die in der eigenen Codesammlung in mehreren Projekten verwendet werden kann.

Für einige AVR (z. B. ATmega169, ATmega48/88/168, AT90CAN jedoch nicht für z. B. ATmega16/32, ATmega128, ATtiny2313) wird durch die Registerdefinitionen der avr-libc (io*.h) auch für Controller mit zwei UBRR-Registern (UBRRL/UBRRH) ein UBRR bzw. UBRR0 als "16-bit-Register" definiert und man kann den Wert direkt per UBRR = UBRR_VAL zuweisen. Intern werden dann zwei Zuweisungen für UBRRH und UBRRL generiert.

<c>
/* UART-Init Bsp. ATmega48 */

void uart_init(void)
{
UBRR0 = UBRR_VAL;
UCSR0B |= (1<<TXEN0);
// Frame Format: Asynchron 8N1
UCSR0C = (1<<UCSZ01)|(1<<UCSZ00);
}
</c>

Die einzelne Anweisung ist nicht bei allen Controllern möglich, da die beiden Register nicht bei allen aufeinanderfolgende Addressen aufweisen. Die getrennte Zuweisung an UBRRH und UBRRL wie im nächsten Beispiel gezeigt, ist universeller und portabler und daher vorzuziehen. Wichtig ist, dass UBRRH '''vor''' UBRRL geschrieben wird:

<c>
/* UART-Init Bsp. ATmega16 */

void uart_init(void)
{
UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL & 0xFF;

UCSRB |= (1<<TXEN); // UART TX einschalten
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // Asynchron 8N1
}
</c>

Inzwischen gibt es in der avr-libc Makros für obige Berechnung der UBRR Registerwerte aus Taktrate F_CPU und Baudrate BAUD. Dazu wird die Includedatei [http://www.nongnu.org/avr-libc/user-manual/group__util__setbaud.html <util/setbaud.h>] eingebunden, nachdem F_CPU und die gewünschte Baudrate definiert wurden. Einige Beispiele zur Anwendung finden sich in der Dokumentation der avr-libc. Im Quellcode kann dann analog zur oben gezeigten Vorgehensweise einfach das Makro UBRR_VALUE (bzw. UBRRH_VALUE und UBRRL_VALUE) an der entsprechenden Stelle eingesetzt werden. Es wird auch automatisch ermittelt, ob der U2X-Modus (vgl. Datenblatt) zu geringeren Abweichungen führt und dann dem Makro USE_U2X ein Wert ungleich null zugewiesen. Ein Beispiel (angelehnt an die avr-libc-Dokumentation):

<c>
#include <avr/io.h>
#define F_CPU 1000000 /* evtl. bereits via Compilerparameter definiert */
#define BAUD 9600
#include <util/setbaud.h>

void uart_init(void)
{
UBRRH = UBRRH_VALUE;
UBRRL = UBRRL_VALUE;
/* evtl. verkuerzt falls Register aufeinanderfolgen (vgl. Datenblatt)
UBRR = UBRR_VALUE;
*/
#if USE_2X
/* U2X-Modus erforderlich */
UCSRA |= (1 << U2X);
#else
/* U2X-Modus nicht erforderlich */
UCSRA &= ~(1 << U2X);
#endif

// hier weitere Initialisierungen (TX und/oder RX aktivieren, Modus setzen
}
</c>

Siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/group__util__setbaud.html Dokumentation der avr-libc zu <util/setbaud.h>]
* [http://www.wormfood.net/avrbaudcalc.php WormFood's AVR Baud Rate Calculator] online.
* [http://www.gjlay.de/helferlein/avr-uart-rechner.html AVR Baudraten-Rechner] in JavaScript

== Senden mit dem UART ==

=== Senden einzelner Zeichen ===

Um nun ein Zeichen auf die Schnittstelle auszugeben, müssen wir dasselbe
lediglich in das '''U'''ART '''D'''ata '''R'''egister schreiben. Vorher ist zu prüfen, ob das UART-Modul bereit ist, das zu sendende Zeichen entgegenzunehmen. Die Bezeichnungen des/der Statusregisters mit dem Bit UDRE ist abhängig vom Controllertypen (vgl. Datenblatt).

<c>
// bei neueren AVRs steht der Status in UCSRA/UCSR0A/UCSR1A, hier z. B. fuer ATmega16:
while (!(UCSRA & (1<<UDRE))) /* warten bis Senden moeglich */
{
}

UDR = 'x'; /* schreibt das Zeichen x auf die Schnittstelle */
</c>

=== Schreiben einer Zeichenkette (String) ===

Die Aufgabe "String senden" wird durch zwei Funktionen abgearbeitet. Die universelle/controllerunabhängige Funktion uart_puts übergibt jeweils ein Zeichen der Zeichenkette an eine Funktion uart_putc, die abhängig von der vorhandenen Hardware implementiert werden muss. In der Funktion zum Senden eines Zeichens ist darauf zu achten, dass vor dem Senden geprüft wird, ob der UART bereit ist den "Sendeauftrag" entgegenzunehmen.

<c>
/* ATmega16 */
int uart_putc(unsigned char c)
{
while (!(UCSRA & (1<<UDRE))) /* warten bis Senden moeglich */
{
}

UDR = c; /* sende Zeichen */
return 0;
}

/* puts ist unabhaengig vom Controllertyp */
void uart_puts (char *s)
{
while (*s)
{ /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
uart_putc(*s);
s++;
}
}
</c>

Die in uart_putc verwendeten Schleifen, in denen gewartet wird bis die UART-Hardware zum senden bereit ist, sind insofern etwas kritisch, da während des Sendens eines Strings nicht mehr auf andere Ereignisse reagiert werden kann. Universeller ist die Nutzung von FIFO(first-in first-out)-Puffern, in denen die zu sendenden bzw. empfangenen Zeichen/Bytes zwischengespeichert und in Interruptroutinen an die U(S)ART-Hardware weitergegeben bzw. von ihr ausgelesen werden. Dazu existieren fertige Komponenten (Bibliotheken, Libraries), die man recht einfach in eigene Entwicklungen integrieren kann. Es empfiehlt sich, diese Komponenten zu nutzen und das Rad nicht neu zu erfinden.

=== Schreiben von Variableninhalten ===

Sollen Inhalte von Variablen (Ganzzahlen, Gleitkomma) in "menschenlesbarer" Form gesendet werden, ist vor dem Transfer eine Umwandlung in Zeichen ("ASCII") erforderlich. Bei nur einer Ziffer ist diese Umwandlung relativ einfach: man addiert den ASCII-Wert von Null zur Ziffer und kann diesen Wert direkt senden.

<c>
#include <avr/io.h>
#include <stdlib.h>
//...

// hier uart_putc (s.o.)

int main (void)
{
// Ausgabe von 0123456789
char c;

uart_init();

for (uint8_t i=0; i<=9; ++i) {
c = i + '0';
uart_putc( c );
// verkuerzt: uart_putc( i + '0' );
}

while (1) {
;
}

return 0; // never reached

}
</c>

Soll mehr als eine Ziffer ausgegeben werden, bedient man sich zweckmäßigerweise vorhandener Funktionen zur Umwandlung von Zahlen in Zeichenketten/Strings. Die Funktion der avr-libc zur Umwandlung von vorzeichenbehafteten 16bit-Ganzzahlen (int16_t) in Zeichenketten heißt ''itoa'' (Integer to ASCII). Man muss der Funktion einen Speicherbereich zur Verarbeitung (buffer) mit Platz für alle Ziffern, das String-Endezeichen ('\0') und evtl. das Vorzeichen bereitstellen.

<c>
#include <avr/io.h>
#include <stdlib.h>

//...

// hier uart_init, uart_putc, uart_puts (s.o.)

int main(void)
{
char s[7];
int16_t i = -12345;

uart_init();

itoa( i, s, 10 ); // 10 fuer radix -> Dezimalsystem
uart_puts( s );

// da itoa einen Zeiger auf den Beginn von s zurueckgibt verkuerzt auch:
uart_puts( itoa( i, s, 10 ) );

while (1) {
;
}

return 0; // never reached
}
</c>

Für vorzeichenlose 16bit-Ganzzahlen (uint16_t) exisitert ''utoa''. Die Funktionen für 32bit-Ganzzahlen (int32_t und uint32_t) heißen ''ltoa'' bzw. ''ultoa''. Da 32bit-Ganzzahlen mehr Stellen aufweisen können, ist ein entsprechend größerer Pufferspeicher vorzusehen.

Auch Gleitkommazahlen (float/double) können mit bereits vorhandenen Funktionen in Zeichenfolgen umgewandelt werden, dazu existieren die Funktionen ''dtostre'' und ''dtostrf''. dtostre nutzt Exponentialschreibweise ("engineering"-Format). (Hinweis: z.Zt. existiert im avr-gcc kein "echtes" double, intern wird immer mit "einfacher Genauigkeit", entsprechend float, gerechnet.)

dtostrf und dtostre benötigen die libm.a der avr-libc. Bei Nutzung von Makefiles ist der Parameter -lm in in LDFLAGS anzugeben (Standard in den WinAVR/mfile-Makefilevorlagen). Nutzt man AVRStudio als IDE für den GNU-Compiler (gcc-Plugin) ist die libm.a unter Libaries auszuwählen: Project -> Configurations Options -> Libaries -> libm.a mit dem Pfeil nach rechts einbinden. Siehe auch die [[FAQ#Aktivieren_der_Floating_Point_Version_von_sprintf_beim_WinAVR_mit_AVR-Studio|FAQ]]

<c>
#include <avr/io.h>
#include <stdlib.h>

//...

// hier uart_init, uart_putc, uart_puts (s.o.)

/* lt. avr-libc Dokumentation:
char* dtostrf(
double __val,
char __width,
char __prec,
char * __s
)
*/

int main(void)
{
// Pufferspeicher ausreichend groß
// evtl. Vorzeichen + width + Endezeichen:
char s[8];
float f = -12.345;

uart_init();

dtostrf( f, 6, 3, s );
uart_puts( s );
// verkürzt: uart_puts( dtostrf( f, 7, 3, s ) );

while (1) {
;
}

return 0; // never reached
}
</c>

== Empfangen ==
=== Einzelne Zeichen empfangen ===

Zum Empfang von Zeichen muss der Empfangsteil des UART bei der Initialisierung aktiviert werden, indem das RXEN-Bit im jeweiligen Konfigurationsregister (UCSRB bzw UCSR0B/UCSR1B) gesetzt wird. Im einfachsten Fall wird solange gewartet, bis ein Zeichen empfangen wurde, dieses steht dann im UART-Datenregister (UDR bzw. UDR0 und UDR1 bei AVRs mit 2 UARTS) zur Verfügung (sogen. "Polling-Betrieb"). Ein Beispiel für den ATmega16:

<c>
#include <inttypes.h>
#include <avr/io.h>

/* Siehe auch obere Baudrateneinstellung */
/* USART-Init beim ATmega16 */

void uart_init(void)
{
UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL & 0xFF;

UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // Asynchron 8N1
UCSRB |= (1<<RXEN); // UART RX einschalten
}

/* Zeichen empfangen */
uint8_t uart_getc(void)
{
while (!(UCSRA & (1<<RXC))) // warten bis Zeichen verfuegbar
;
return UDR; // Zeichen aus UDR an Aufrufer zurueckgeben
}
</c>

Und die Anwendung in einem Beispiel:

<c>
#include <avr/io.h>
#include <stdlib.h>

// hier Makro für die Baudratenberechnung

// hier uart_init, uart_getc (s.o.)

int main(void)
{
uart_init();
while (1)
{
uint8_t c;
c = uart_getc();

// hier etwas mit c machen z.B. auf PORT ausgeben
DDRC = 0xFF; // PORTC Ausgang
PORTC = c;
}
return 0; // never reached
}
</c>

Die Funktion uart_getc() blockiert allerdings den Programmablauf, denn es wird gewartet, bis ein Zeichen empfangen wird! Möchte man das Warten vermeiden, kann das RXC-Bit in einer Programmschleife abgefragt werden und dann nur bei gesetztem RXC-Bit UDR ausgelesen werden.

<c>
#include <avr/io.h>
#include <stdlib.h>

// hier Makro für die Baudratenberechnung

// hier uart_init, uart_getc (s.o.)

int main(void)
{
uart_init();
while (1)
{
if ( (UCSRA & (1<<RXC)) )
{
// Zeichen wurde empfangen, jetzt abholen
uint8_t c;
c = uart_getc();
// hier etwas mit c machen z.B. auf PORT ausgeben
DDRC = 0xFF; // PORTC Ausgang
PORTC = c;
}
else
{
// Kein Zeichen empfangen, Restprogramm ausführen...
}
}
return 0; // never reached
}
</c>

Eleganter und in den meisten Anwendungsfällen "stabiler" ist die Vorgehensweise, die empfangenen Zeichen in einer Interrupt-Routine einzulesen und zur späteren Verarbeitung in einem Eingangsbuffer (FIFO-Buffer) zwischenzuspeichern. Dazu existieren fertige und gut getestete [[Libraries|Bibliotheken]]  und Quellcodekomponenten (z. B. UART-Library von P. Fleury, procyon-avrlib und einige in der "Academy" von avrfreaks.net).

Siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/group__avr__stdlib.html Dokumenation der avr-libc/stdlib.h]
* [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Die_Nutzung_von_sprintf_und_printf Die Nutzung von sprintf und printf]
* [http://homepage.hispeed.ch/peterfleury/ Peter Fleurys] UART-Bibiliothek fuer avr-gcc/avr-libc


TODO: 9bit

=== Empfang von Zeichenketten (Strings) ===

Beim Empfang von Zeichenketten, muß man sich zunächst darüber im klaren sein, daß es ein Kriterium geben muß, an dem der µC erkennen kann, wann ein Text zu Ende ist. Sehr oft wird dazu das Zeichen 'Return' benutzt, um das Ende eines Textes zu markieren. Dies ist vom Benutzer einfach eingebbar und er ist auch daran gewöhnt, daß er eine Eingabezeile mit einem Druck auf die Return Taste abgeschlossen wird.

Prinzipiell gibt es jedoch keine Einschränkung bezüglich dieses speziellen Zeichens. Es muß nur sichergestellt werden, daß dieses spezielle 'Ende eines Strings' - Zeichen nicht mit einem im Text vorkommenden Zeichen verwechselt werden kann. Wenn also im zu übertragenden Text beispielsweise kein ';' vorkommt, dann spricht nichts dagegen, den Benutzer die Eingabe eines Textes mit einem ';' abschließen zu lassen.

Im Folgenden wird die durchaus übliche Annahme getroffen, daß eine Stringübertragung identisch ist mit der Übertragung einer Textzeile und daher mit einem Return ('\n') abgeschlossen wird.

Das Problem der Übertragung eines Strings reduziert sich damit auf die Aufgabenstellung: Empfange und sammle Zeichen in einem char Array, bis entweder das Array voll ist oder das Text Ende Zeichen' empfangen wurde. Danach wird der empfangene Text noch mit einem '\0' Zeichen abgeschlossen um einen Standard C-String daraus zu machen, mit dem dann weiter gearbeitet werden kann.

<C>
/* Zeichen empfangen */
uint8_t uart_getc(void)
{
while (!(UCSRA & (1<<RXC))) // warten bis Zeichen verfuegbar
;
return UDR; // Zeichen aus UDR an Aufrufer zurueckgeben
}

void uart_gets( char* Buffer, uint8_t MaxLen )
{
uint8_t NextChar;
uint8_t StringLen = 0;

NextChar = uart_getc(); // Warte auf und empfange das nächste Zeichen

// Sammle solange Zeichen, bis:
// * entweder das String Ende Zeichen kam
// * oder das aufnehmende Array voll ist
while( NextChar != '\n' && StringLen < MaxLen - 1 ) {
*Buffer++ = NextChar;
StringLen++;
NextChar = uart_getc();
}

// Noch ein '\0' anhängen um einen Standard
// C-String daraus zu machen
*Buffer = '\0';
}
</C>

Beim Aufruf ist darauf zu achten, dass das empfangende Array auch mit einer
vernünftigen Größe definiert wird.

<C>

char Line[40]; // String mit maximal 39 zeichen

uart_gets( Line, sizeof( Line ) );
</C>

Bei der Benutzung von sizeof() ist allerdings zu beachten, dass sizeof() nicht die Anzahl der Elemente des Arrays liefert, sondern die Länge in Byte. Da ein char nur ein Byte lang ist, passt der Aufruf 'uart_gets(Line, sizeof( Line ) );' in diesem Fall. Falls man - aus welchen Gründen auch immer - andere Datentypen benutzen möchte, sollte man zur korrekten Angabe der Array-Länge folgende Vorgehensweise bevorzugen:

<C>
int Line[40]; // Array vom Typ int

uart_gets( Line, sizeof( Line ) / sizeof( Line[0] ) );
</C>

==Interruptbetrieb==

Hier wird das Grundwissen des Artikels [[Interrupt]] und des Abschnitts [[AVR-GCC-Tutorial#Programmieren_mit_Interrupts|AVR-GCC-Tutorial: Programmieren_mit_Interrupts]] vorausgesetzt.

=== Empfangen (RX) ===

Beim ATmega8 muss das '''RXCIE''' Bit im Register UCSRB gesetzt werden, damit ein Interrupt beim Empfang eines Zeichens ausgelöst werden kann.

<c>
/* siehe auch obere Baudrateneinstellung */
/* USART-Init beim ATmega16 */
void uart_init(void)
{
UCSRB |= (1<<RXEN)|(1<<TXEN)|(1<<RXCIE); // UART RX, TX und RX Interrupt einschalten
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // Asynchron 8N1

UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL & 0xFF;
}
</c>

Natürlich muss "Global Interrupt Enable" mittels des Befehls sei() aktiviert sein. Interrupt-spezifische Definitionen werden über die Includedatei eingebunden:

<c>
#include <avr/interrupt.h>
</c>

Der Interrupt wird immer ausgelöst, wenn ein Zeichen erfolgreich empfangen wurde. Zusätzlich braucht man die Interruptserviceroutine (ISR).

In diesem Beispiel enthält die ISR einen FIFO-Puffer (First in, First out). Dafür werden ein paar globale Variablen und Makros benötigt:

<c>
#define UART_MAXSTRLEN 10

volatile uint8_t uart_str_complete = 0; // 1 .. String komplett empfangen
volatile uint8_t uart_str_count = 0;
volatile char uart_string[UART_MAXSTRLEN + 1] = "";
</c>

<c>
ISR(USART_RXC_vect)
{
unsigned char nextChar;

// Daten aus dem Puffer lesen
nextChar = UDR;
if( uart_str_complete == 0 ) { // wenn uart_string gerade in Verwendung, neues Zeichen verwerfen

// Daten werden erst in uart_string geschrieben, wenn nicht String-Ende/max Zeichenlänge erreicht ist/string gerade verarbeitet wird
if( nextChar != '\n' &&
nextChar != '\r' &&
uart_str_count < UART_MAXSTRLEN - 1 ) {
uart_string[uart_str_count] = nextChar;
uart_str_count++;
}
else {
uart_string[uart_str_count] = '\0';
uart_str_count = 0;
uart_str_complete = 1;
}
}
}
</c>

Zur Funktion: Wurde eine komplette Zeichenkette empfangen, also das Ende (\n oder \r) erkannt oder die maximale Länge ''UART_MAXSTRLEN'' erreicht, wird die globale Variable ''uart_str_complete'' auf '1' gesetzt. Damit wird dem Hauptprogramm, welches auf diese Variable pollt, mitgeteilt, dass die Zeichenkette ''uart_string'' zur Verarbeitung bereit steht. Nach der Verarbeitung der Zeichenkette in der entsprechenden main-Routine, muss die Variable ''uart_str_complete'' wieder auf '0' zurück gesetzt werden. Dadurch werden alle neu empfangenen Zeichen wieder in den globalen Puffer geschrieben.

=== (Baustelle) ===

* Empfangen (Receive) (Anm.: z.T. erledigt)
** ggf. Fallstricke ([http://www.mikrocontroller.net/topic/84256#707214 UDR in der ISR lesen!])
** Komplettes, einfaches Beispiel ([http://www.mikrocontroller.net/topic/84228#707052 Echo] (noch buggy beim Datenzugriff, siehe Lit. 2+3!)), ggf. LED zur ISR-Empfangsanzeige oder Overflow-Anzeige

* Senden (Transmit)
** Variante "UART Data Register Empty" (UDRE) [http://www.mikrocontroller.net/topic/101472#882716]
** Variante "UART Transmit Complete" (TXC)

* FIFO-Puffer [http://www.mikrocontroller.net/topic/101472#882716], Ringpuffer (Byte Buffering (circular))

* UART-Bibliotheken
** [http://homepage.hispeed.ch/peterfleury/avr-software.html UART-Library] von Peter Fleury (UART (interrupt driven), Byte Buffering (circular))
** [http://www.procyonengineering.com/embedded/avr/avrlib/ Procyon AVRlib] von Pascal Stang (UART (interrupt driven), Byte Buffering (circular), VT100 Terminal Output)

* Literatur
** [http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=48188 avrfreaks.net Tutorial] inkl. Diskussion (engl.)
** avr-libc FAQ: [http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_16bitio Why do some 16-bit timer registers sometimes get trashed?]

==Software-UART==

Falls die Zahl der vorhandenen Hardware-UARTs nicht ausreicht, können weitere Schnittstellen über sogennante Software-UARTs ergänzt werden. Es gibt dazu (mindestens) zwei Ansätze:
* Der bei AVRs üblichste Ansatz basiert auf dem Prinzip, dass ein externer Interrupt-Pin für den Empfang ("RX") genutzt wird. Das Startbit löst den Interrupt aus, in der Interrupt-Routine (ISR) wird der externe Interrupt deaktiviert und ein Timer aktiviert. In der Interrupt-Routine des Timers wird der Zustand des Empfangs-Pins entsprechend der Baudrate abgetastet. Nach Empfang des Stop-Bits wird der externe Interrupt wieder aktiviert. Senden kann über einen beliebigen Pin ("TX") erfolgen, der entsprechend der Baudrate und dem zu sendenden Zeichen auf 0 oder 1 gesetzt wird. Die Implementierung ist nicht ganz einfach, es existieren dazu aber fertige Bibliotheken (z. B. bei [http://www.avrfreaks.net/ avrfreaks] oder in der [http://www.procyonengineering.com/embedded/avr/avrlib/ Procyon avrlib]).
* Ein weiterer Ansatz erfordert keinen Pin mit "Interrupt-Funktion" aber benötigt mehr Rechenzeit. Jeder Input-Pin kann als Empfangspin (RX) dienen. Über einen Timer wird der Zustand des RX-Pins mit einem vielfachen der Baudrate abgetastet (dreifach scheint üblich) und High- bzw. Lowbits anhand einer Mindestanzahl identifiziert. (Beispiel: "Generic Software Uart" Application-Note von IAR)

Neuere AVRs (z. B. ATtiny26 oder ATmega48,88,168,169) verfügen über ein Universal Serial Interface (USI), das teilweise UART-Funktion übernehmen kann. Atmel stellt eine Application-Note bereit, in der die Nutzung des USI als UART erläutert wird (im Prinzip "Hardware-unterstützter Software-UART").

==Handshaking==
Wenn der Sender ständig sendet, wird irgendwann der Fall eintreten, daß der Empfänger nicht bereit ist, neue Zeichen zu empfangen. In diesem Fall muß durch ein '''Handshake-Verfahren''' die Situation bereinigt werden. Handshake bedeutet nichts anderes, als daß der Empfänger dem Sender mitteilt, daß er zur Zeit keine Daten annehmen kann und der Sender die Übertragung der nächsten Zeichen solange einstellen soll, bis der Empfänger signalisiert, daß er wieder Zeichen aufnehmen kann.
===Hardwarehandshake (RTS/CTS)===
Beim Hardwarehandshake werden zusätzlich zu den beiden Daten-Übertragungsleitungen noch 2 weitere Leitungen benötigt: '''RTS''' ('''R'''equest '''T'''o '''S'''end) und '''CTS''' ('''C'''lear '''T'''o '''S'''end). Jeder der beiden Kommunikationspartner ist verpflichtet, bevor ein Zeichen gesendet wird, den Zustand der '''RTS''' Leitung zu überprüfen. Nur wenn die Gegenstelle darauf Empfangsbereitschaft signalisiert, darf das Zeichen gesendet werden. Um der Gegenstelle zu signalisieren, daß sie zur Zeit keine Zeichen schicken soll, wird die Leitung '''CTS''' benutzt.

===Softwarehandshake (XON/XOFF)===
Beim Softwarehandshake sind keine speziellen Leitungen notwendig. Statt dessen werden besondere ASCII-Zeichen benutzt, die der Gegenstelle signalisieren, daß Senden einzustellen bzw. wieder aufzunehmen. 
* '''XOFF''' Aufforderung das Senden einzustellen
* '''XON''' Gegenstelle darf wieder senden

Nachteilig bei einem Softwarehandshake ist es, dass dadurch keine direkte binäre Datenübertragung mehr möglich ist. Von den möglichen 256 Bytewerten werden ja 2 (nämlich '''XON''' und '''XOFF''') für besondere Zwecke benutzt und fallen daher aus.

==Galvanische Trennung==
Für eine geringe Überspannungsfestigkeit empfielt es sich, die Datenkanäle über Optokoppler zu führen. Es bietet sich z.b. der 6N138 an, ein "normaler" CNY-17 ist für hohe Baudraten nicht brauchbar.

==Fehlersuche==
Erstaunlich oft wird im Forum der Hilferuf laut: "Meine UART funktioniert nicht, was mache ich falsch". In der überwiegenden Mehrzahl der Fälle stellt sich dann heraus, daß es sich um ein Hardwareproblem handelt, wobei da wiederrum der Löwenanteil auf das Konto einer nicht korrekt eingestellten Taktrate geht: Der µC benutzt nicht einen angeschlossenen Quarz, so wie er auch im Programm eingetragen ist, sondern läuft immer noch mit dem internen RC-Takt. Daraus resultiert aber auch, daß der Baudraten Konfigurationswert falsch berechnet wird.

Hilfreich zum Aufspüren solcher Fehler ist auch die [[AVR_Checkliste#UART/USART|AVR-Checkliste]].

==Links==
Tipps zur Verarbeitung von Strings sind in den [[FAQ]].

[[Kategorie:avr-gcc Tutorial]]
[[Kategorie:UART und RS232]]

Diskussion:Sms command

2011-07-15T12:10:59Z

145.225.60.4: Die Seite wurde neu angelegt: „Das gibt es schon als Artikel hier im Forum, siehe: http://www.mikrocontroller.net/articles/Versenden_von_SMS_mittels_Mobiltelefon Da wird auch das Steuern von G…“

Das gibt es schon als Artikel hier im Forum, siehe:
http://www.mikrocontroller.net/articles/Versenden_von_SMS_mittels_Mobiltelefon

Da wird auch das Steuern von Geräten und das Auswerten von Nutzereingaben via SMS behandelt

Diskussion:GMSK-Modulation

2011-07-13T07:59:04Z

145.225.60.4: Die Seite wurde neu angelegt: „Hast du zu dem Gauss Filter auch einen Frequenzgang?“

Hast du zu dem Gauss Filter auch einen Frequenzgang?

Minila Version MockUp

2010-12-22T12:49:16Z

145.225.60.4: /* FTDI */

== Bilder der Platine ==
=== Gerenderte Platine ===
[[Bild:MockUpMiniLALayoutTop.jpg|400px]]
[[Bild:MockUpMiniLALayoutBottom.jpg|400px]]

=== Platine der Sammelbestellung bestückt ===
[[Bild:MockUpMiniLALayoutTopPrototyp.jpg|400px]]
[[Bild:MockUpMiniLALayoutBottomPrototyp.jpg|400px]]

== Informationen über den MiniLA ==

=== CPLD ===
* wird der XC95288XL bleiben, da dies nur eine Veränderung und keine Neuentwicklung wird
* einige Signale werden an anderen Pins angeschlossen und verteilt
* TQFP144

=== RAM-Speicher ===
512K*32:
* 512K*32 Kanäle
* TQFP100 0,65mm Pinabstand
* GS816036
* [ http://de.farnell.com/gsi-technology/gs816032bgt-200/18m-synch-burst-sram-512kx32-smd/dp/1447526 Optional GS816032]
* [ http://www.cypress.com/?mpn=CY7C1381D-133AXC Optional CY7C1381D-133AX]
* wird in der Sammelbestellung verwendet

1M*32:
* 1M*32 Kanäle
* TQFP100 0,65mm Pinabstand
* CY7C1441AV33-133AXC/CY7C1441AV33-133AXI
* 60eur/stk
* dazu muss eine Brücke zwischen TP1 am CPLD und TP2 am SRAM eingelötet werden
[[Bild:MockUpMiniLALayout1MBitRAM.png|200px]]

=== USB ===
Der FTDI FT2232D wird immer im Bus Powerd Modus betrieben und über USB versorgt.

=== Spannungsversorgung ===
* 3,3V, Versorgung über externe 5V bis 16V oder über den DCDC USB powered (Regler wird über den FTDI An/Aus geschaltet)
* 5V über DCDC (galvanisch getrennt) mit Spannungsregler dahinter oder DCDC überbrückt direkt über USB

Dadurch kann der MiniLA mit einem Y-Kabel USB versorgt werden oder über ein externes Netzteil.

=== Galvanische Trennung ===
Als Zusatzoption über den ADUM4160, einem DCDC-Wandler und einem zusätzlichem Spannungsregler.

=== Steckverbinder ===
* Steckerbelegung bleibt beim alten
* X1-7 wird entfernt, da eh wenig Platz im CPLD ist
* X8 bleibt erhalten
* K8 wird dann auch komplett entfernt, da nicht mehr benötigt (alle Signale sind auch an K1 verfügbar)
* Serienwiderstände in den Datenleitungen wie gehabt
* Tastköpfe extern wie gehabt (siehe auch: Platinen)

=== JTAG ===
* JTAG-Signale liegen an einem MicroMatch Steckverbinder an.
* Programmierung über FTDI und "xc3sprog" http://www.mikrocontroller.net/articles/MiniLA#via_USB

=== Parallel Port ===
* nicht vorgesehen
* Signale liegen an einem MicroMatch Steckverbinder an

=== LEDs ===
Je nach Wunsch in SMD 0805 oder als 5mm LED

=== Gehäuse ===
Passende Gehäusen:
* Hammond 1455L1602 (Mouser, RS, Conrad usw.)
* Fischer AKG 105 30 160 (RS, DK, Conrad usw.)
* Fischer AKG 105 34 160 (RS, DK, Conrad usw.)
* RFS RF-1599 (rfsupplier.com)

Auch 3,5" USB/eSATA Festplatten-Gehäuse sind bestens geeignet.

== Schaltplan und Layout ==
=== Schaltplan ===
'''Seite 1 & 2''' 
[[Bild:MockUpMiniLASchaltplanSheet1.png|350px]]
[[Bild:MockUpMiniLASchaltplanSheet2.png|350px]]

'''Seite 3 & 4''' 
[[Bild:MockUpMiniLASchaltplanSheet3.png|350px]]
[[Bild:MockUpMiniLASchaltplanSheet4.png|350px]]

'''Seite 5 & 6''' 
[[Bild:MockUpMiniLASchaltplanSheet5.png|350px]]
[[Bild:MockUpMiniLASchaltplanSheet6.png|350px]]

'''Seite 7''' 
[[Bild:MockUpMiniLASchaltplanSheet7.png|350px]]

=== Layout ===
''' Platine Mini-LA ''' 
[[Bild:MockUpMiniLALayoutEagleTop.png.png|350px]]
[[Bild:MockUpMiniLALayoutEagleBottom.png|350px]]
* 2-lagig
* über den 5mm LEDs sind die SMD0805 LEDs angeordnet
* [[Datei:MiniLAVersionMockUpV1_05a.zip]]
* [[Datei:MiniLAVersionMockUpTeileliste.zip]]
''' Platine Tastköpfe '''
* Sind über Wigbert zu beziehen. Er hat noch Tastköpfe von der ersten Sammelbestellung.

=== Steckverbinder auf der Platine ===
{| class="wikitable"
|+ '''Steckverbinder'''
|-
! || nicht gesteckt || gesteckt 1-2 || gesteckt 2-3
|-
| JP2 || - || Normal Modus || JTAG-Programmierung über FTDI
|-
| JP3 || - || Normal Modus || JTAG-Programmierung über FTDI
|-
| JP4 || - || Normal Modus || JTAG-Programmierung über FTDI
|-
| JP5 || - || Normal Modus || JTAG-Programmierung über FTDI
|-
| JP6 || - || - || -
|-
| JP7 || Platine "AUS" || Platine "AN" || -
|-
| JP9 || - || externe Versorgung || USB Versorgung
|}

JP6 - Spannungsversorgung für einen Externen Programmieradapter ('''nicht Brücken!''')

== Programmierung ==
[[Image:MiniLAVersionMockUpFTPROG1.png|thumb|150px|right|Programmierung des FTDIs, Bild1]][[Image:MiniLAVersionMockUpFTPROG2.png|thumb|150px|right|Programmierung des FTDIs, Bild2]]
=== FTDI ===
Zum Programmieren werden die [http://www.ftdichip.com/Drivers/VCP.htm FTDI-Treiber] und das Programm [http://www.ftdichip.com/Support/Utilities.htm FT_PROG] benötigt.

*1. MiniLA über ein USB Kabel an den PC anschließen und die heruntergeladenen Treiber Installieren
*2. Das Programm FT_PROG starten
*3. Im Programm auf "Scan and Parse" drücken (1)(Bild1)
*4. rechte Maustaste auf den erkannten FTDI, "Aply Template" und "From File" [http://www.mikrocontroller.net/attachment/95887/MiniLA.xml diese Datei] auswählen (2)(Bild1)
*5. Im Programm auf "Program Devices" drücken (3)(Bild1), ein neues Fenster öffnet sich (Bild2)
*6. Hacken setzen (4)(Bild2)
*7. Auf "Program" drucken (5)(Bild2)
*8. MiniLA abstecken und wieder anklemmen
*9. Fertig

=== LibUSB ===
[[Image:MiniLAVersionMockUplibUSB1.png|thumb|150px|right|LibUSB einrichten, Bild1]][[Image:MiniLAVersionMockUplibUSB2.png|thumb|150px|right|LibUSB einrichten, Bild2]]
Zur Programmierung des CPLDs über xc3prog wird LibUSB benötigt. Dies bekommt man [http://sourceforge.net/projects/libusb-win32/files/libusb-win32-releases/ hier]. Die letzte Version anklicken und dann "libusb-win32-bin-x.x.x.x.zip" herunterladen und entpacken.
*1. In den Ordner "bin" und "x86" für Windows XP 32Bit wechseln
*2. "install-filter-win.exe" starten
*3. "Install a device filter" und "Next" drücken
*4. In der Liste auf "USB Serial Converter A" drücken (1) und danach auf Install (2) (Bild1)
*5. In der Liste auf "USB Serial Converter B" drücken (3) und danach noch einmal auf Install (4) (Bild2)
*6. Mit "Cancel" (5) Abbrechen (Bild2)
*7. Fertig

=== Firmware ===
[[Image:MiniLAVersionMockUpxc3prog.png|thumb|150px|right|Programmierung des CPLDs]]
Zum Programmieren wird [http://sourceforge.net/projects/xc3sprog/ xc3sprog] benötigt. [http://www.mikrocontroller.net/attachment/95662/xc3sprog.exe Hier eine angepasste Version (Mit der anderen gab es Probleme beim EPROM löschen).]

*1. Auf dem MiniLA die Jumper JP2-JP5 in die Stellung [http://www.mikrocontroller.net/articles/Minila_Version_MockUp#Steckverbinder_auf_der_Platine 2-3] umstecken und den MiniLA anschließen.
*2. Kommandozeile öffnen
*3. In den Ordner wechseln, in der xc3prog und die jed-Datei liegt. (Die jed-Datei aus dem Archiv extrahieren. Sie ist im Ordner xilinx zu finden.)
*4. "xc3prog -c ftdi -v miniLA.jed" eingeben und Enter drücken.
*5. Der FTDI sollte programmiert werden, ähnlich dem nebenstehendem Bild.

'''Hilfreiche Befehle'''
* "xc3prog -c ftdi -v -j" - Erkennung des CPLDs
* "xc3prog -c ftdi -v -e" - Löschen des CPLDs

Die firmware ist nur lauffähig mit der Version des MockUp MiniLAs!
* [http://www.mikrocontroller.net/wikifiles/f/f5/Fw_timeanalysis_v1.8_for_MockUp_miniLA.zip Timeanalysis v1.8]
* [http://www.mikrocontroller.net/wikifiles/2/27/Fw_stateanalysis_v2.3_for_MockUp_miniLA.zip Stateanalysis v2.3]

== Software ==

* soon ...

== Sammelbestellung ==
Ich nehme zurzeit die Anfragen für den MiniLA entgegen (MockUp). Wir planen mit 50 Bausätzen, davon sind bis jetzt:
* 50 verbindlich vergeben
 Es sind somit keine mehr Verfügbar!

Die angebotenen Sachen:
*Z0 - Bausatz ohne galvanische Trennung (inkl. Platine) - 87EUR
*Z1 - Restliche Bauteile für die Galvanische Trennung mit 2W DCDC - 18EUR
*Z2 - Restliche Bauteile für die Galvanische Trennung mit 3W DCDC - 27EUR
*Z3 - Gehäuse - Hammond 1455L1602 Alu von Mouser - 13EUR
*Z4 - Platine(es sind nur 25 extra vorhanden zu den 50) - 10EUR
*Z5 - SMD Bestückung - 9EUR

== Links ==
* [http://www.mikrocontroller.net/topic/174860#new Hauptthread auf Mikrocontroller.net]
* [http://www.mikrocontroller.net/articles/MiniLA Original]
* [http://minila.sourceforge.net/hw/other/bg/minila_bg_sch.pdf Schaltplan der alten Version]

[[Kategorie:Projekte]]

Avr Webserver mit Wiznet WIZ810MJ

2008-08-27T09:26:10Z

145.225.60.4: /* Hardware */

==Hardware==
* Atmega128
* 32kB SRAM
* WIZ810MJ Ethernetmodul
* FT245R
* CAN galvanisch getrennt
* SD Karte
* RS232
* Software SPI

Alle unbelegten Pins sind auf Stiftleisten geführt und können für freie Anwendungen verwendet werden, z.B. für ein LC Display.

==Platine==
[[Bild:webserver.jpg|framed]]
Die Platinen wurden bei Leiton gefertigt.

'''Eagle Files:''' [[Media:Webserver-PCB.zip|WiznetWebserverPCB]]

'''Schaltplan im PDF Format:''' [[Media:Webserver-Schematic.pdf|Schaltplan als PDF]]

'''Bestückungsplan:''' [[Media:WebserverBestueckung.pdf|Bestückungsplan als PDF]]

Hier ein Bild eines fertig aufgebauten Webservers:

==Programmiermöglichkeiten==
Auf der Platine ist eine 6-polige Stiftleiste zum Programmieren vorhanden. Weiters wurde ein Bootloader geschreiben, durch den es möglich ist, den Avr mittels RS232 oder über USB zu programmieren. Der Bootloader ist STK500 kompatibel, wodurch man einfach mit dem AVR Studio oder mit Avrdude programmieren kann.

==Aufbau==
Beachtung gilt der DC Buchse. Es gibt mehrere Versionen dieser Buchse. Die Buchse besitzt 3 Anschlüsse. Besitzt der seitliche Anschluss kontakt zum hinteren Anschluss, muss dieser abgschnitten werden. Ansonsten kommt es zu einem Kurzschluss der Eingangsspannung.
Da sich unter dem Quarz für den Atmega128 mehrere Durchkontaktierungen befinden, muss der Quartz isoliert werden. Es gibt dafür spezielle Quarzisolierscheibchen. Ansonsten tut es auch ein Stück Kunststofffolie (zB ein Heftumschlag).

==Software==
===Speichertestprogramm===
Um den externen SRAM testen zu können wurde ein Speichertestprogramm geschrieben. Es beschreibt den kompletten RAM in einer Schleife. Danach wird er wieder ausgelesen und die Differenz zum geschriebenen Wert berechnet. Ist das Ergebnis 0, wurde die Speicherzelle richtig beschrieben und ausglesen. Ist das Ergbnis ungleich Null, trat während des Vorganges ein Fehler auf, wird die Led1 (PG4) wird eingeschalten. Nach beenden der Speicherprüfung wird die Led2 (PG3) geschalten. Leuchtet nur eine der beiden Leds, ist das Ergebnis des Speichertests OK. Leuchten beide Leds, ergab sich während des Auslesens ein Fehler. In diesem Fall sollte man die Lötstellen des SRAMs, Latches und AVR kontrollieren. Zusätzlich werden die Informationen auch über die serielle Schnittstelle ausgegeben. Baudrate ist 115200 bps eingestellt.

'''Memtest Programm:''' [[Media:Memtest.zip|Memtest]]

===Bootloader===
Der Bootloader ist STK500 kompatibel, wodurch der ATmega128 direkt aus dem AVR Studio geflasht werden kann.

'''Bootloaderroutinen mit Applikationsbeispiel zum Testen:''' [[Media:Webserver.zip|Bootloaderroutinen mit Applikationsbeispiel]]

Mit dem Define 'COMM_MODE' in der Header-Datei communication.h kann festgelegt werden, ob der Bootloader für RS232 oder USB ist. Diese Header befindet sich im Ordner Webserver_STK500_Bootloader.

====Voreinstellungen====
Damit der Bootlaoder funktioniert, muss zuerst die hex Datein Webserver_STK500_Bootloader.hex im Ordner Webserver_STK500_Bootloader\defaultmit einem externen Programmiergerät über die 6-polige Stiftleiste geflasht werden. Weiters müssen die Fusebits richtig eingestellt werden. Folgendes muss eingestellt werden:
* ATmega103 Kompatiblitätsmodus deaktivieren
* JTAG und On-Chip-Debugging deaktivieren
* Externen Quarz aktivieren
* Bootresetvektor aktivieren
* Bootsize = 1024 words

Die Werte für die Fuses, die die obrigen Einstellungen beinhalten, sind 0xFF (low Fuse) und 0xDC (high Fuse).

Will man den Bootloader für USB verwenden, muss man einerseits das Define 'COMM_MODE' in der Header-Datei communication.h für USB einstllen (Standardmäßig ist USB gewählt), andererseits muss der COM Port Treiber für den FT245 installiert werden. Diesen findet man hier http://www.ftdichip.com/Drivers/VCP.htm. Genauere Informationen zur Installation können auf der FTDI Homepage nachgelsen werden.

====Informationen zur Nutzung====
Der Bootloader wurde mit dem AVR-Studio sowohl über USB als auch RS232 getestet. Probleme können auftreten, wenn der Bootlaoder für USB eingestellt ist und man USB - während man im AVR-Studio vebunden ist - absteckt. Sollte man dies doch tun, muss man zuerst den Connect-Dialog schließen, anschließend USB neu anstecken und erneut verbinden. In einer anderen Reihenfolge kann sein, dass man keine neue Verbindung aufbauen kann. Über RS232 treten diese Probleme nicht auf. Die Probleme über USB liegen möglicherweise am COM-Port Treiber von FTDI, da die Software am µC für die Auswertung der STK500 Kommandos für RS232 und USB gleich ist.

====Applikationen flashen====
Im Ordner vom Bootlaoder ist auch ein Applikationsbeispiel. Dieses Projekt kann verwendet werden, um hier seine eigenen Applikationen zu schreiben. Um eine Hex-Datei zu flashen, kann einfach über RS232 oder den USB-COM-Port im AVR-Studio eine Verbindung zum Webserver aufgebaut werden und die hex geflasht werden. Wichtig ist noch, dass in einer selbst erstellten Applikation die USB-Routinen/RS232-Routinen mitkopiliert und sowohl USB als auch RS232 wie im mitgelieferten Beispiel initialisiert werden, damit der Bootlaoder funktioniert und jederzeit eine neue Applikation geflasht werden kann. Ansonsten muss der Bootloader immer wieder neu geflasht werden.

==Interface==
Alle Routinen für die vorhanden Interfaces des Webservers sind bereits im Applikationsbeispiel enthalten, siehe [[Avr_Webserver_mit_Wiznet_WIZ810MJ#Bootloader|Applikationsbeispiel mit Bootloaderroutinen]]).

===External Memory Interface===
Da sich am Webserver mehrere Devices am XMEM-Interface befinden, musste eine Logik entwickelt werden, mit der je nach selektierter Adresse immer nur das jeweilig angesprochene Device aktiv ist.
Am XMEM Inteface befinden sich folgende Devices:
* 32kB SRAM: Adresse 0x0000-0x7FFF
* Wiznet Modul WIZ810MJ: Adresse 0x8000-0xFFFF
* USB FT245: beliebige Adresse zwischen 0xA000-0xAFFF (nicht genutzer Bereich des Wiznet Moduls)

Die gesamte Logikschaltung mit ausführlicher Dokumentierung kann hier heruntergeladen werden: [[Media:Adresslogik_für_Webserver.pdf|Adresslogik für Webserver.pdf]]

===USB===
Der Webserver hat eine USB Schnittstelle und verwendet den FT245 von FTDI Chip als USB Chip. Der FT245 ist am XMEM Interface des Webservers angeschlossen und kann in einem fix vorgegebenem Adressbereich liegen (siehe External Memory Interface).

Für den Webserver wird der COM-Port Treiber von FTDI verwendet, der zuvor installiert werden muss (siehe auch [[Avr_Webserver_mit_Wiznet_WIZ810MJ#Voreinstellungen|Bootloader Voreinstellungen]]).

====Übertragungsprotokoll====
Das Übertragungsprotokoll war nötig und an den STK500 Bootloader gebunden, damit es auch möglich ist, von der Applikation in den Bootlaoder zu springen. Die Übertragung ist folgendermaßen aufgebaut:
* START
** 0x1B reserviert für Daten aus AVR Studio
**anderes 8 bit Startbyte, das ungleich 0x1B ist, kann für USER Daten verwendet werden
* Sequence Number
** 8 bit breit
* Message Size 1
** MSB der Message Size (Anazhl der Datenbytes)
* Message Size 2
** LSB der Message Size (Anzahl der Datenbytes)
* Datenblock
** Messagesize (16bit) Datenbytes zu je 8bit
* Checksumme
** XOR aus allen Bytes einer Message (START, SeqNum, MsgSize1, MsgSize2, DATA)

Wird als START Byte ein 0x1B erkannt, dann wird die Funktion collectCompleteMessage() aus der Header Datei BootlaoderApplication.h aufgerufen, die nichts anderes macht, als zu warten, bis eine vollständige Message empfangen wurde, diese anschließend in der .noinit section speichert und daraufhin einen Reset mit dem Watchdog generiert, damit der Webserver in den Bootlaoder springt. Dort wird dann erkannt, dass ein Watchdog Reset ausgelöst wurde und neue Daten in der .noinit section für den Bootloader sind. Diese werden daraufhin ausgelesen und verarbeitet.

====Probleme an FT245 Pins TXE und RXF====
Beim Testen der Platine und des FT245 hat sich herausgestellt, dass nach dem Anstecken der Stromversorgung oder nach dem Anstecken von USB am PC einige high-low Pulse an TXE und RXF auftreten. Diese waren insofern ein Problem als die Datenauswertung in der Hauptapplikation (nicht im Bootloader) interruptgesteuert erfolgt und ein Übertragungsprotokoll (für STK500 Bootloader nötig) verwendet wird. Diese Pulse wurden nun per Software kompensiert, dafür war jedoch der Timer0 notwendig. Der Timer0 kann somit nur mehr bedingt für eigene Anwendungen verwendet werden, empfohlen wird jedoch, diesen Timer nicht zu verwenden.

===UART RS232===
Auf der Webserver Platine befindet sich ein MAX3232 für die Pegelwandlung. Für RS232 wurden die Routinen aus der AVRlib verwendet (sowohl uart.h/uart.c als auch rprintf.h/rprintf.c). Damit man den Bootloader für RS232 verwenden kann, war es jedoch notwendig, die Receive Interruptroutine in der uart.c für den Webserver anzupassen. Für RS232 wird nun dasselbe Übertragungsprotokoll wie für USB verwendet. Siehe [[Avr_Webserver_mit_Wiznet_WIZ810MJ#.C3.9Cbertragungsprotokoll|USB Übertragungsprotokoll]]

===CAN===
* Hardware SPI
* MCP2515
* CAN Transceiver
* Galvanische Trennung mit DC-DC Wandler und Optokoppler
* Latch, für SD nötig

===SD-Karte===
[[Bild:SdKarteFehler.png|top|framed|Diese beiden Leiterbahnen müssen aufgetrennt werden]]
* Hardware-SPI
* Latch, damit CS auf low bleibt

Leider hat sich ein Fehler im Schaltplan eingeschlichen. Zwei Netze haben den gleichen Namen und haben somit eine Verbindung untereinander. Dieser Fehler wurde aber beim Routen nicht erkannt und somit gibt es hier eine Verbindung. Nach neun Stunden Debugging wurde der Fehler gefunden. Damit die Ansteuerung der SD-Karte aber funktioniert, müssen zwei Leiterbahnen aufgetrennt werden. Im Bild links sind die notwendigen Schnitte orange und gelb eingezeichnet. Für das Verhalten der Schaltung hat diese Leitung (Datenausgang der SD-Karte) keinen Einfluss. Da die SD-Karte intern Pullup-Widerstände besitzt, hat SD-Karte auch bei offenem CS-Signal einen definierten Pegel.

Für die FAT-Implementation wird eine vorgefertigte Bibliothek von [http://www.holger-klabunde.de/ Holger Klabunde] verwendet. Es wurde ein einfacher Schreib- und Lesetest für den Webserver implementiert. Das Programm liest eine Datei ein und gibt sie über die serielle Schnittstelle aus. Weiters schreibt das Programm im Root-Verzeichnis der SD-Karte eine Datei. Danach wird ein neues Verzeichnis angelegt und darin eine weitere Datei geschrieben. Die Debug-Ausgaben erfolgen über die serielle Schnittstelle mit einer Bitrate von 115000bps.

'''SD-Karten-Beispiel:''' [[Media:WebserverSDBsp.zip|Schreib- und Lesetest]]

===Software SPI===
Da Hardware SPI des ATmega128 bereits für CAN und SD Karte verwendet wurden, wurde am Webserver auch ein softwaremäßiges SPI Interface eingebunden. Für die Software SPI Pins ist eine eigene 6-polige Stiftleiste auf der Platine vorgesehen.
Die Routinen sind in Assembler geschrieben und erzeugen einen SCK Takt von F_CPU/32. Die Assemblerfunktionen steuern nur SSMISO, SSMOSI und SSCK. Die Chipselect Leitung muss vom User vor Funktionsaufruf gesteuert bzw. initialisert werden.

===Ethernet===

[[Category:Projekte|A]]
[[Category:AVR|A]]
[[Category:Ethernet|A]]