Mikrocontroller.net - Benutzerbeiträge [de]

Vorlage für Projektbeschreibung

2009-09-25T15:15:06Z

84.58.239.213: /* Siehe auch */ Tipp zu den Kategorien

''von NAME''

== Einleitung ==

Hier steht eine Beschreibung des Projekts. Eine Beschreibung besteht aus dem Titel und einer Liste von Features.

Eine Liste von Features:

* Feature 1
* Feature 2
* Feature 3

Es ist sinnvoll, dem Projekt einen vernünftigen Namen zu geben. Viele der Projekte und Artikel haben das 'AVR' als Anfang im Namen stehen. Das erscheint sinnvoll, ist es aber nicht, denn in der alphabetischen Sortierung stehen diese alle unter 'A'. Besser wäre es, einen Namen zu vergeben, der mit dem Zweck des Projektes übereinstimmt. Also:

Nicht 'AVR-Drehgeberdecoder' sondern
'Gray-Code decoder für Drehgeber'

Bei Software, die nur auf dem AVR läuft, kann das 'AVR' als Suchtag verwendet werden. Falls die Software so geschrieben ist, dass sie auf mehreren verschiedenen CPUs läuft, soll keine CPU im Titel genannt werden.

== Software ==

Beschreibung der Software

== Downloads ==
* Sourcecode: http://www.mikrocontroller.net/attachment.php/123/Sourcecode.zip
* Schaltplan: http://www.mikrocontroller.net/attachment.php/1234/Schaltplan.pdf

== Siehe auch ==
* Diskussion zu diesem Projekt: http://www.mikrocontroller.net/forum/read-4-123.html
* [[Audio-Projekt|Link zu anderem Projekt]]

Am eine des Artikels erfolgt eine Einsortierung in Artikel-Schublade(n), auch Kategorie(n) genannt. Damit ist Dein Artikel leichter auffindbar.

Such aus den vorhandenen [[Spezial:Kategorien|Kategorien]] diejenige(n) aus, die am besten auf den Artikel passen.



[[Kategorie:AVR-Projekte| ]]
[[Category:Projekte| ]]
[[Kategorie:Tipps für Autoren]]

Uhr

2009-09-25T15:07:29Z

84.58.239.213: --> Kategorie:AVR-Projekte

Dieser kleine Code zeigt die beispielhafte Implementierung einer Siebensegment Uhr.

==Version 1.0==
===Eckdaten===
{| class="wikitable"
|+ '''Eckdaten'''
|-
! Eigenschaft || Wert
|-
| Controller || AVR ATTiny2313
|-
| Spannung || 5V
|-
| Quarz || erforderlich; 8MHz
|-
| Flashspeicherbelegung || 746Bytes (36,4%)
|-
| SRAM-Belegung || 18Bytes (14,1%)
|}

===Code===
<c>
/*
Belegungen:
PB0 B PD0 1er, PNP-Transistor
PB1 C PD1 10er, PNP-Transistor
PB2 D PD2 100er, PNP-Transistor
PB3 E PD3 1000er, PNP-Transistor
PB4 F PD4 -
PB5 G PD5 Schalter, interne Pullups sind an
PB6 DP PD6 -
PB7 A

Takt:
8MHZ Quarz

Siebensegmentanzeige:
Gemeinsame Anode
*/

#include <avr/io.h> //Grundfunktionen
#ifndef F_CPU //Vordefinieren für delay.h
#define F_CPU 8000000UL //Definition von F_CPU in Herz
#endif
#include <util/delay.h> //Warteschleifen
#include <avr/interrupt.h> //Interruptheader

//Konstanten
//Hier kann man den Code an seine Siebensegment Anzeige anpassen
const unsigned char Zahl[10] = {0b01100000, 0b11111100, 0b01010010, 0b01011000, 0b11001100, 0b01001001, 0b01000001, 0b01111100, 0b01000000, 0b01001000};
//Globale Variablen
volatile unsigned long int Sekunden=0; //32Bit Variable; 24Bit würdens auch tun
unsigned char Tausender;
unsigned char Hunderter;
unsigned char Zehner;
unsigned char Einer;

ISR(TIMER1_COMPA_vect) //Bei Compare-Match mit OCR1A (31250) wird Sekunden um eins erhöht.
{
Sekunden++;
if (Sekunden >= 86400) //Wenn 24h vorbei sind, wird wieder auf 0 gesetzt
Sekunden = 0;
}

void Berechnung (void) //Sekunden zu BCD
{
Tausender = (Sekunden / 3600) / 10;
Hunderter = (Sekunden / 3600) - Tausender*10;
Zehner = ((Sekunden % 3600) / 60) / 10;
Einer = ((Sekunden % 3600) / 60) - Zehner*10;
}

void Einstellen (void) //Dient dem Einstellen der Uhr
{
if ( !(PIND & (1<<PIND5)) )
Sekunden = Sekunden + 60;
}

void Anzeige (void) //Zeigt die BCD Werte an, Eine 4fach Siebensegmentanzeige wird gemultiplexed
{
unsigned int i; //Variable für die Schleife
for (i=10; i>0; i--) //10*12ms=120ms Schleifenlaufzeit
{
PORTD=0b01110111; //PD3 an --- Tausenderstelle
PORTB=Zahl[Tausender];
_delay_ms(3);

PORTD=0b01111011; //PD2 an --- Hunderterstelle
PORTB=Zahl[Hunderter];
PORTB &= ~((1 << PB6)); //löscht Bit 6 in PORTB, dadurch wird der Punkt zwischen den Stunden und Minuten angezeigt
_delay_ms(3);

PORTD=0b01111101; //PD1 an --- Zehnerstelle
PORTB=Zahl[Zehner];
_delay_ms(3);

PORTD=0b01111110; //PD0 an --- Einerstelle
PORTB=Zahl[Einer];
_delay_ms(3);
}
}

int main (void)
{
//Registerinitialisierung
TCCR1A = 0b00000000; //Timer im CTC-Mode; Prescaler 256; CPU-Clock
TCCR1B = 0b00001100; //Timer im CTC-Mode; Prescaler 256; CPU-Clock
TCCR1C = 0b00000000; //Timer im CTC-Mode; Prescaler 256; CPU-Clock
TIMSK = 0b01000000; //Interrupt bei Compare Match
OCR1A = 31249; //genau eine Sekunde; Comparematch-Register
DDRB = 0b11111111; //Alles Ausgang; Siebensegmentanzeige
DDRD = 0b11011111; //PD5 ist Eingang
sei(); //Interrupts an
//Hauptschleife
while(1)
{
Berechnung();
Anzeige();
Einstellen();
}
}

</c>

[[Kategorie:AVR-Projekte]]
[[Category:Timer und Uhren]]

Projekt Netzteiltester

2009-09-25T15:04:43Z

84.58.239.213: /* Weblinks */ --> Kategorie:AVR-Projekte

[[Bild:Pstester_img_1.jpg|thumb|Der Netzteiltester in Aktion]]

== Features ==
* Über RS232 vom PC aus frei einstellbare Pulsfolgen, die mit 1kHz Wiederholrate ausgegeben werden
* Auf Wunsch Speicherung der Folgen-Definition im [[EEPROM]] des Controllers
* Erzeugung eines Trigger-Impulses für das Oszilloskop (externe Triggerung)
* Verwendung eines leistungsfähigen HEXFETs von International Rectifier, deshalb sollten Ströme bis 20A kein Problem sein (habe es noch nicht selbst ausprobiert, bei 3A war jedenfalls keine Erwärmung des FETs spürbar)
* 0.1 Ohm Keramik-Shuntwiderstand zur Strommessung
* Platine kleiner als halbe Eurokarte (d.h. kleiner als 80x100mm), trotzdem keine SMD Parts

== Hardware ==
* [[AVR|ATMega8]] mit 16MHz Quarz
* [[RS-232]] Schnittstelle für die Kommunikation mit PC
* IRF 1404 HEXFET als Leistungstransistor

== Bekannte Probleme ==
bisher sind keine Probleme bekannt :-)

== Kontakt und Diskussion ==
Natürlich freue ich mich auf jeden Kommentar und auf jede Anregung (Flames wandern trotzdem in den Mülleimer :)

In Bälde mehr ...

--[[Benutzer:Cl|Cl]] 15:36, 14. Mär 2005 (CET)

== Weblinks ==

* [http://www.elektronik-kompendium.de/public/schaerer/pstst1.htm Netzteiltester von Thomas Schaerer] inclusive ausführlicher Erklärung

[[Kategorie:AVR-Projekte]]
[[Kategorie:Spannungsversorgung und Energiequellen]]

Ambilight in Hardware

2009-09-25T15:03:42Z

84.58.239.213: /* Downloads */ --> Kategorie:AVR-Projekte

[[Category:1. Wettbewerb]]

''von Martin Antoni''

== Einleitung ==

Dieses Projekt ist ein Nachbau des bekannten AmbiLights von Philips.
Ambilight steht für Umgebungslicht und soll den Bildschirm optisch vergrößern, indem es die Bildfarben an die Wand projeziert.
Mit Hilfe eines kleinen Mikrocontrollers habe ich die Bildinhalte ausgewertet und per [[PWM]] an RGB-[[LED]]s geschickt.

'''Features'''

* günstiger MC ATMega48
* kein Computer notwendig
* 8*8 Matrix Bildauswertung
* 128 Farbstufen (noch erweiterbar)

== Hintergrund ==

Im Internet habe ich schon einige Varianten gefunden, welche z.B. mit einer Software den Bildinhalt auswerten und dann an einen Mikrocontroller mit RGB-LED schicken.
Dabei ist das Problem der Verzögerung und man braucht einen Computer zum Auswerten.
Bei diesem Projekt kann direkt ein S-Video-Signal oder ein FBAS-Signal (siehe Ausblick) angeschlossen werden.

== Grundlagen ==

'''FBAS'''

Das FBAS-Signal setzt sich aus dem Schwarz-Weiß-Signal (BAS) und dem Farbsignal zusammen. Das Farbsignal ist auf dem Schwarz-Weiß-Signal aufmoduliert.

Ein Bild ist in 625 Zeilen aufgeteilt, jede Zeile ist 64us lang. Die Übertragung geschieht in Halbbildern. Zuerst werden die ungeraden Zeilen(1, 3, 5, 7, ...) übertragen, im Anschluss kommen die geraden Zeilen (2, 4, 6, ...).
Zusätzlich zu den Bildzeilen sind noch Synchronsignal im BAS-Signal moduliert. Eine genaue Beschreibung lässt sich auf folgenden Seiten finden:

[http://de.wikipedia.org/wiki/Fernsehsignal Wikipedia Fernsehsignal]

[http://www.elektroniktutor.de/techno/pal_ffs.html Fernsehtechnik]

Das Farbsignal kann man unterteilen in Farbart und Farbsättigung. Diese beiden Informationen sind Quadraturamplitudenmoduliert. In der Phase steckt die Farbart und in der Amplitude die Farbsättigung.
Dieses modulierte Signal ist bei einer Frequenz von 4,433MHz auf das BAS-Signal moduliert. Mit einem [[Filter|Tiefpassfilter]] lässt sich das BAS-Signal herausfiltern, mit einem Hoch- oder Bandpass lässt sich das Farbsignal herausfiltern.

'''YUV'''

YUV ist ein Farbraum, mit einem Helligkeitssignal (Y) und zwei Farbsignalen (U + V).
Dieser wird bei FBAS verwendet, das Y-Signal wird als BAS-Signal übertragen und die U- und V-Signale werden QAM auf das BAS-Signal moduliert als FBAS.

[http://de.wikipedia.org/wiki/YUV YUV auf Wikipedia]
== Hardware ==

Die Hardware kann in logische Blöcke aufgeteilt werden.

* Integrator
* Demodulator
* Auswertung
* Farbhilfsträger

'''Integrator'''

Ich habe das Bild in 64 Felder unterteilt, sozusagen eine 8*8-Matrix, für jedes Feld steht der RGB-Wert zur Verfügung. Damit können Lichter an verschiedenen Positionen hinter dem Fernseher angesteuert werden. Es müssen nur die richtigen Felder ausgewertet werden. Z.B. Feld 0 - 7 für die obere Bildkante.

Jede Zeile ist in 8 Felder unterteilt.
Ich integriere jeweils über 1/8 der Zeile, der Endwert wird dann mit einer Sample-&-Hold-Schaltung so lange gehalten, bis der AD-Wandler fertig ist. In der nächsten Zeile wird dann das nächste Achtel integriert. Nach 8 Zeilen habe ich somit eine komplette Zeile analysiert.

[[Bild:Integrator.png]]

Insgesamt werden 512 Zeilen pro Bild analysiert, 8 Zeilen braucht man um eine komplette Zeile zu analysieren, das macht dann 64 wirkliche Bildzeilen. Da eine 8*8-Matrix verwendet wird, addiere ich immer 8 Zeilen. Jedes Feld besteht aus 8 Bildzeilenabschnitten aufaddiert.

Für die Integratorschaltung verwende ich eine abgewandelte Negativ-Impedanz-Schaltung. Diese, mit einem RC-Glied voran, bildet einen nichtinvertierdenden Integrator.

Ich verwende 3 Integratoren, für das Helligkeitssignal Y, das U- und das V-Signal.

Der Eingang jedes Integrators ist mit einem Mosfet (BS170) gegen Masse versehen. Wenn dieser Mosfet einschaltet, ist der Eingang auf Masse gelegt und somit wird eine Spannung von 0V integriert. 0 Integriert ergibt 0, somit ist das eine Sample-&-Hold-Schaltung.

'''Demodulator'''

Um aus dem Quadraturamplitudenmodulierten Signal wieder das U- und das V-Signal zuerhalten, verwende ich einen Produkt-Detektor. Das Hauptelement ist ein Balanced Modulator (MC1496). Im Datenblatt ist auf Seite 10 ist die Schaltung zu sehen.
Ich habe die Schaltung übernommen und hab die Werte der Bauelement angepasst. An den Ausgang habe ich einen Differenzverstärker mit einem Verstärkungsfaktor 2 und einer Offsetspanung von 2,5V gebaut.

Für das U-Signal brauche ich 0° Phasenverschiebung vom Referenzoszillator und für das V-Signal brauche ich 90° Phasenverschiebung. Beide Sinussignale kommen vom Referenzoszillator (siehe Farbhilfsträger).

Die Ausgänge der Modulatoren gehen an die Eingänge der Integratoren.

'''Auswertung'''

Das Herz der Schaltung ist der ATMega48. An PORTC hängen die ADC-Ports.

* PC0 - U-Integrierer
* PC1 - V-Integrierer
* PC2 - Y-Integrierer

* PC3 - Sample-&-Hold U
* PC4 - Sample-&-Hold V
* PC5 - Sample-&-Hold Y

Im Kapitel Software ist beschrieben, wie die Ports angesteuert werden müssen, um die Signale zu integrieren.

'''Farbhilfsträger'''

Für eine korrekte Demodulation des Quadratursignales muss ein Referenzsignal in korrekter Phase und Frequenz zur Verfügung stehen.

Der Farbhilfsträger wird von einem Quarzoszillator erzeugt, welcher über eine PLL an die Farbfrequenz des Fernsehsignales angepasst wird.

Der [[Oszillator]] ist ein Colpitts-Quarzoszillator. Um den Oszillator abzustimmen, wird normalerweise eine Kapazitätsdiode verwendet. In meiner Schaltung verwende ich jedoch eine 1N4001. Diese hat eine geringere Kapazitätsänderung, reicht aber völlig aus. Je nach Sperrspannung verändert sich die Diffusionskapazität. Damit wird der Quarz gezogen.

Der Abgleich findet mit dem Burst statt. Der Burst ist ein Paket von Sinusschwingungen am Anfang (fast) jeder Zeile. Die Phase des Burst wird bei jeder Zeile um 90° hin- und hergeschaltet. Somit verwende ich nur jeden zweiten Burst, um den Referenzoszillator abzustimmen.

Die Ausgangsspannung des Colpitts-Oszillators ist mit Oberwellen übersäht. Um eine reine Sinusschwingung zu erzeugen, habe ich ein LC-Tiefpassfilter mit eingebaut.

Wie schon im Kapitel Demodulator erwähnt, braucht man zwei um 90° phasenverschobene Signale. Ich nutze den Fakt, dass der Burst immer um 45° phasenverschoben ist.
Ein zweites Tiefpassfilter erzeugt nochmal 45° Phasenverschiebung, somit habe ich 90°.
Für die 0° Phasenverschiebung habe ich ein Hochpassfilter eingebaut. Dieses Filter erzeugt -45° Phasenverschiebung. Damit werden die 45° des Bursts kompensiert.
Am Ausgang kommt jeweils ein Emitterfolger, um das Tief- bzw. Hochpassfilter nicht zu belasten.

Dieses Bild zeigt die um 45° verschobenden Sinen.

[[Bild:Oszillator.png]]

== Software ==

Die Software ist komplett in Assembler geschrieben. Nur so habe ich die komplette Kontrolle über das Timing.

Die Hauptaufgabe wird in Interrupts abgearbeitet, welche durch Timer ausglöst werden.
Die Berechnung der RGB-Signale erfolgt in der Main Loop.

'''H-Sync und V-Sync'''

[[Bild:frame_odd.png]]
[[Bild:frame_even.png]]

Die beiden Bilder zeigen die Sync-Signale des BAS-Signales bei Zeile 1 und Zeile 313. Bei Zeile 1 fängt ein Even Frame an, bei Zeile 313 fängt ein Odd Frame an.

Um die Sync-Signale auszuwerten ist am Pin PD.2 der Komparator angeschlossen, welcher ein High-Signal erzeugt, sobald das BAS-Signal unter 0,1V geht. Am Pin PD.2 ist außerdem der Pullup eingebaute Pullup eingeschaltet, um sich einen externen Widerstand zu sparen.

Der externe Interrupt ist auf steigende Flanke eingestellt. Dann wird der Timer2 im CTC-Modus gestartet. Überlaufzeit beträgt 24us. In den Bildern erkennt man die Überläufe des Timers 2.
Bei jedem Überlauf wird geschaut, ob ein V-Sync Signal vorliegt. Wenn beim ersten Überlauf der Syncwert gleich dem Syncwert des zweiten Überlaufes ist, beginnt ein Odd Frame (Bild links). Bei unterschiedlichen Syncwerten beginnt ein Even Frame (Bild rechts).
Die Aufgabe des Timers 2 ist nur das Sync-Signal zu extrahieren und die aktuelle Zeilennummer zu bestimmen.

'''Messung der Helligkeits- und Farbsignale'''

Der Timer1 ist für den Burst-Gate-Impuls und für die Integration über die Zeile zuständig. Wenn ein H-Sync-Impuls (ext. Int0) kommt, wird der Timer1 gestartet. Beim ersten Überlauf wird der Burst-Gate-Impuls generiert. Beim zweiten mal Überlaufen wird die Integration gestartet und beim dritten Überlaufen wird die Integration gestoppt und die Sample-&-Hold-Schaltungen alle gleichzeitig gestartet.
Anschließend wird der AD-Wandler gestartet, welcher nacheinnander alle 3 Signale wandelt. Die Wandlung von allen 3 Signalen dauert ca. 33us.

[[Bild:Integrate.png]]

Dieses Bild zeigt 4 Linien mit dem BAS-Signal (blau). Das pinke Signal ist die Integration mit Sample & Hold. Man erkennt, dass bei hellerem Bild (höhere blaue Linie) der Endwert der Integration höher ist.
Außerdem erkennt man gut, dass bei der nächsten Linie ein Achtel weiter hinten integriert wird. Die Länge der S-&-H-Phase ist die AD-Wandlung, ca. 11us pro Wandlung.

Um eine Messung zu starten, setze ich das DDRC-Register auf Ausgang, damit wird der Integrator-Kondensator entladen und die Schaltung auf Null gesetzt. Dann wird für 1/8 der Zeit integriert, indem das DDRC-Register auf Eingang und die Sample-&-Hold-Schaltung auf aus gesetzt wird.

'''Berechnung der RGB-Werte'''

In Zeile 10 des Bildes werden die Y-, U- und V-Matrix auf Null gesetzt. Bis zur Zeile 620 werden alle Integrationswerte gespeichert und aufaddiert. Bei Zeile 620 beginnt nun die Berechnung.

Der Y-Wert wird auf 127 normiert, somit hat er einen Wertebereich von 0-127.
Das geschieht mit der Multiplikation vom Matrixwert mit 0,1875. Der Wert wurde durch ausprobieren herausgefunden. Die Multiplikation wird mit fractional numbers durchgeführt.
Die Normierung ist nötig, da mit Vorzeichen gerechnet wird und höhere Zahlen dann negativ wären.

Anschließend wird der U-Wert normiert und mit 0,25 multipliziert. Dieser Wert wurde auch durch ausprobieren herausgefunden. Nun wird der U-Wert und der Y-Wert addiert und das Blausignal ist fertig.

Das Rotsignal wird ähnlich berechnet, nur dass die V-Matrix verwendet wird und der Multiplikant ist 0,22. Auch hier wird der V-Wert und der Y-Wert addiert und man erhält das Rotsignal.

Das Grünsignal muss mit Y-, U- und V-Signal berechnet werden. Die U- und V-Signale werden wieder normiert und diesmal von Helligkeitssignal Y abgezogen.
Damit erhält man das Grünsignal. Der Multiplikant für U ist 0,047 und für V ist er 0,078.

== Ausblick ==

Die Schaltung funkioniert gut. Es gibt aber noch einige Verbesserungsmöglichkeiten.

Die Kondensatoren bei den Integratoren sind zu klein, damit wird das Signal verfälscht, sobald der Mega48 seine interne S-&-H-Schaltung aktiviert. Je nachdem, ob der interne Kondensator voller oder leerer als der vom Integrator, gibt es Ausgleichvorgänge, welche nicht unerheblich sind. Am besten wäre eine 10-50 höhere Kapazität beim Integrator. Dann müssten die Widerstände noch angepasst werden.

Die PLL-Schaltung schwingt etwas, das Tiefpassfilter müsste noch optimiert werden.

Zur Zeit verwende ich [[Soft-PWM]], da ich nur noch einen Timer übrig habe, das heißt nur 2 PWM-Kanäle. Besser wäre es, einen größeren Mega zu nehmen oder externe PWM-Bausteine zu verwenden.

Die Schaltung lässt sich nur mit einem S-Video mit getrennten Farb- und Helligkeitsignal betreiben. Wenn ein FBAS-Signal angeschlossen werden soll, müssen noch ein Tiefpass und ein Hochpass eingebaut werden.

Der Burst-Detektor arbeitet noch nicht zuverlässig, da ich nur den internen Pullup-Widerstand verwendet habe. In der nächsten Version muss ein externer Widerstand hin und das Poti kann durch ein Festwiderstand ersetzt werden.

Zur Zeit gebe ich nur ein Feld an die LEDs aus. Man müsste noch über mehrere Felder mitteln, dann würde die LEDs nicht so stark reagieren auf Bildänderungen.

== Downloads ==
* Sourcecode: [[Bild:Ambilight1 1.zip]]
* Schaltplan: [[Bild:Ambi bilder.zip]]

[[Kategorie:AVR-Projekte]]
[[Category:Displays und Anzeigen]]

MMC/SD Bootloader für AT Mega

2009-09-25T15:01:19Z

84.58.239.213: -= Kategorie:Projekte

= Beschreibung =
Dieser [[Bootloader]] wird einmalig, z.B. per PonyProg, STK500, etc., in einen AVR Atmega geschrieben. Ab nun kann das Hauptprogramm mit Hilfe einer SD oder MMC Speicherkarte in den µC geschrieben werden.
Um sicherzustellen dass das Gerät mit dem richtigen Update beschrieben wird, wird im Hauptprogramm mit Hilfe einer Section am Ende des Hauptprogramms eine eindeutige Hardware-ID, eine Software-Versionsnummer und eine Prüfsumme hinterlegt.
Zum Aktualisieren des Hauptprogrammes wird im selbigen die Versionnummer erhöht, kompiliert, und mit einem kleinen Kommandozeilen-Tool die CRC berechnet und in die Datei geschrieben. Diese Datei wird dann auf eine Speicherkarte kopiert, an den µC angeschlossen, und der µC resettet.

= Ausstattung =
* Passt in 2 kB Bootsection, also z.B. auch für Atmega8 geeignet
* Liest von MMC und SD Karten mit oder ohne MBR, die mit FAT16 oder FAT12 formatiert sind
* Anhand einer 4 Byte langen Kennung, die im Bootloader und im Hauptprogramm hinterlegt ist, wird die passende Datei auf der Karte geladen. So ist es möglich Updates für verschiedene Geräte gleichzeitig auf der Karte zu haben
* CRC Überprüfung der eingespielten Software
* Ohne Änderung an Geräten, die nur einen ISP Stecker haben verwendbar. Der CS Pin der Karte wird in diesem Fall auf GND gelegt.
* Optional: Status-LED. Diese wird beim Start des Bootloaders aktiviert, flackert während eines Aktualisierungsvorgangs und verlischt schließlich, wenn die CRC-Prüfung erfolgreich war und das Hauptprogramm gestartet wird.

= Erstellen und Anpassen =
== Bootloader ==
Der Bootloader muss zunächst an den verwendeten µC angepasst werden. Dazu öffnet man zunächst das makefile des Bootloaders und passt diesen Ausschnitt an:

<c>
DEVID = 0x12345678
TARGET = bootloader
BOOTLOADERSTARTADR = 0x3800
BOOTLDRSIZE = 0x800
</c>

Bei der DEVID handelt es sich um eine eindeutige Hardware-Kennung, die für jedes Gerät eindeutig vergeben werden muss.
BOOTLOADERSTARTADR ist die Adresse, auf der der Bootloader liegt, im obigen Beispiel für einen ATMega 16. Dieser hat 16384 Bytes Flash, davon wird die Größe des Bootloaders (2048 Bytes) abgezogen und man erhält 14336 = 0x3800.

Nun muss noch in mmc_lib.h angegeben werden, wo die Speicherkarte angeschlossen ist:

<c>
#define MMC_PORT PORTB
#define MMC_DDR DDRB

#define SPI_MISO PB3 //DataOut of MMC
#define SPI_MOSI PB6 //DataIn of MMC
#define SPI_CLK PB7 //Clock of MMC
#define MMC_CS PB4 //ChipSelect of MMC
</c>

Für CS der Speicherkarte sollte der SS Pin des µC verwendet werden. Der SS Pin muss sowieso auf Ausgang und Low gesetzt werden, weil sonst der SPI Master nicht funktioniert.

== Hauptprogramm ==
Im Hauptprogramm müssen folgende Angaben an entsprechender Stelle im makefile gemacht werden:

<c>
FORMAT = binary
DEVID = 0x12345678
SWVERSIONMAJOR = 1
SWVERSIONMINOR = 0
BOOTLDRSIZE = 0x800
#FLASHSIZE - BOOTLDRSIZE - 8
BOOTLDRINFOSTART = 0x37F8
</c>
<c>
CDEFS += -DDEVID=$(DEVID)
CDEFS += -DSWVERSIONMAJOR=$(SWVERSIONMAJOR)
CDEFS += -DSWVERSIONMINOR=$(SWVERSIONMINOR)
</c>
<c>
LDFLAGS += -Wl,--section-start=.bootldrinfo=$(BOOTLDRINFOSTART)
</c>

Das Format muss zwingend auf binary gesetzt werden. Die DEVID muss mit der des Bootloaders übereinstimmen. Mit SWVERSIONMAJOR und SWVERSIONMINOR wird die Softwareversionsnummer eingestellt. Der Bootloader schreibt das Hauptprogramm nur dann, wenn die Versionnummer auf der Karte größer als im Flash ist.
BOOTLDRINFOSTART ist die Adresse, auf der der Informationsblock (DEVID, Version, CRC) landet. Das Beispiel bezieht sich ebenfalls auf den ATMega16: 16384 Flash - 2048 Bootloader - 8 Bytes Info = 14328 = 0x37F8.

In main.c wird der Infoblock deklariert:

<c>
typedef struct
{
unsigned long dev_id;
unsigned short app_version;
unsigned short crc;
} bootldrinfo_t;

const bootldrinfo_t bootlodrinfo __attribute__ ((section (".bootldrinfo"))) = {DEVID, SWVERSIONMAJOR << 8 | SWVERSIONMINOR, 0x0000};
</c>

Nun kann das Hauptprogramm compiliert werden. Die entstehende .hex Datei (binary Format!) wird anschließend noch mit dem Kommandozeilentool crcgen.exe behandelt (z.B. crcgen myflashfile.hex). Der Aufruf dieses Programmes kann auch vom makefile aus geschehen.

Das Update benennt man am besten etwa in der Form MeinApparat-v1.0-bin, darf aber beliebig (lang) sein .

= Einschränkungen =
* Der Bootloader unterstützt nur FAT12 (Partitionstyp 1) und FAT16 (Partitionstyp 6). Große Karten die mit FAT32 formatiert wurden sind nicht geeignet, und müssen zunächst mit FAT16 formatiert werden.
* Das Update muss im Hauptverzeichnis der Speicherkarte liegen.

= Download und Diskussion =
Der Sourcecode findet sich in der Codesammlung unter
http://www.mikrocontroller.net/topic/67047#new
Immer schön runterscrollen um die brandneueste Version zu erwischen!

= Danke =
an
* Jörg
* holger
* Werner B.
* Hagen Re
für die Codeoptimierung. So konnte die ursprüngliche Fassung, in der nur FAT16 implementiert war, um FAT12 erweitert werden.

[[Category:AVR-Programmer und -Bootloader]]

Layoutsammlung

2009-09-25T14:59:43Z

84.58.239.213: /* Siehe auch */ -->Kategorie:AVR-Projekte

Einige interessante Layouts aus der [http://www.mikrocontroller.net/forum/codesammlung Codesammlung]
----
Symbole zur Kennzeichnung des verwendeten CAD-Systems
{| border="1"
|(E)
|EAGLE Projekt, (E5) = EAGLE 5
|-
|(K)
|[[KiCAD]] Projekt
|-
|(P)
|Protel Projekt
|-
|(T)
|Target Projekt
|-
|(X)
|Rohdaten der Leiterplatte (pdf, gerber, usw.)
|}

----

== Audio ==

* (E) [http://www.mikrocontroller.net/topic/114262 SD-Karten-Wave-Recorder] (ATXMega128A1 + 2x ATTiny2313)

== Entwicklungsboard ==
* (X) [[Zilog Encore Experimentierplatine]]

== Programmieradapter ==

* (E) [[AVR HV-Programmer|Platinenlayout für ElmChans AVR HV-Programmer]]

== RF, Funk ==

* (E) [http://www.mikrocontroller.net/topic/90021#768374 Layout RFM12 Funkmodul]
* (E) [http://www.mikrocontroller.net/topic/68442#552128 USB RFID Tag Leser] für 64 Bit 125 kHz Tags
* (X) [[RFID Türmodul]]

== Sonstiges ==

* (E) [http://www.mikrocontroller.net/topic/120816 Giess-o-mat mit AVR] - Blumengiessanlage mit Atmega8
* (X) [[STK500USB-Adapter]] - USB zu RS232 Adapter mit Schaltregler zur Versorgung des [[STK500]] per USB

== E-Tools ==

* [http://www.mikrocontroller.net/topic/120124 Kleiner Funktionsgenerator mit Tiny2313]
* (E) [http://www.mikrocontroller.net/topic/103600 I2C (TWI) Sniffer mit AVR] (ATtiny85 mit 14,7456MHz Quarz)

== Siehe auch ==

* [[Schaltplaneditoren]]
* [[AVR Softwarepool]]

[[Kategorie:AVR-Projekte]]
[[Category:Platinen]]

CAN Bibiliothek für AT90CAN Prozessoren

2009-09-25T14:57:41Z

84.58.239.213: /* Dateien mit dem Quelltext der Bibliotheksprogramme */ --> Kategorie:AVR-Projekte

Autor: [[Benutzer:Harms|Jürgen Harms]] 16:30, 21. Jul. 2008
==Einleitung==

Dieser Artikel beschreibt eine einfache C-Programmbibliothek für die Programmierung des Zugriffs auf einen CAN Bus mittels eines AVR '''AT90CAN''' Prozessors (AT90CAN128, AT90CAN64 oder AT90CAN32). Zusätzlich beschreibt er eine Demo-Anwendung zum Testen dieser Bibliothek; diese Demo-Anwendung kann aber auch als Anregung für die Gestaltung eines einfachen Echtzeitrahmens für kleine Anwendungen dienen.

===Anwendungsgebiet, Eigenschaften===

Die Bibliothek wurde als Teil eines in C geschriebenen Hausbus Systems entwickelt - daraus ergeben sich die Spezifikationen:

* Die Bibliothek macht die wichtigsten Fähigkeiten der CAN Kontrolleinheit auf der Ebene des Aufrufs von '''C-Unterprogrammen''' verfügbar.

* Die Anwendung muss '''interruptgetrieben''' sein.

* Die Bibliothek verwendet einen einfachen '''Prioritätsmechanismus''' bei der Behandlung von Nachrichten: falls mehrere Nachrichten gleichzeitig auf das Senden oder Empfangen warten, bestimmt dieser Mechanismus welche Nachricht zuerst von der Kontrolleinheit des AT90CAN bedient wird.

* Sie erlaubt sparsamen Umgang mit dynamischem Speicherplatz.

* Bei der Implementierung wurde auf Einfachheit und leichte Lesbarkeit geachtet.

* In der jetzigen Version sind die '''Taktraten fest kodiert''' und setzen einen 16 MHz Quarz voraus (Bus Takt = 100Kbps, interner Takt der CAN Kontrolleinheit = 10Kbps) - diese Parameter sind aber leicht änderbar.

* Mit einer Ausnahme bietet die Bibliothek derzeit keine Vorkehrungen zur '''Behandlung von Fehlern''': die CAN Kontrolleinheit des AT90CAN besorgt weitgehend - und unter normalen Bedingungen ausreichend - die Behandlung von Übermittlungsfehlern. Die Ausnahme betrifft das Erkennen von gesendeten Nachrichten, die während längerer Zeit nicht vom Bus quittiert werden und damit das entsprechende MOb blockieren (der Begriff MOb ist im folgenden Abschnitt definiert).

===Begriffe===

Ein paar Begriffe werden im folgenden häufig verwendet und haben, im Kontext von CAN, eine sehr spezifische Bedeutung:

: Der Begriff '''MOb''' - (''Message Object'') - bezeichnet die Infrastruktur in der Kontrolleinheit, welche zur Darstellung und Behandlung einer Nachricht vorgesehen ist.

: Eine '''Adresse''' (''Identifier Tag'') auf einem CAN Bus bezeichnet eine - für normal Gruppe von - Adressaten. Knoten am Bus beobachten das Adressfeld von Nachrichten und vergleichen es mit Schablonen, die bei der Initialisierung des Knotens definiert wurden. CAN unterscheidet zwischen '''normalen''' und '''erweiterten''' Adressen (dargestellt in 11, bzw. 29 Bits).

: Ein '''Filter''' enthält solch eine Schablone; zusätzlich zu den Bits zur Adressierung von Knoten bestimmt das Filter auch Bits, welche bestimmte Eigenschaften beschreiben. Ein Filter wird getriggert - die entsprechende Nachricht wird vom Knoten empfangen - wenn alle in der Schablone festgelegten Bedingungen erfüllt sind.

===Implementierung, Demo-Anwendung===

Die Bibliothek wurde in einer Unix Programmierumgebung (AVR-Gcc, Make, AVR-Libc) entwickelt. Diese Umgebung gibt es auch in einer ausgezeichneten und gut gewarteten Variante für Windows. Die Bibliothek läuft bei mir ohne bekannte Probleme, allerdings wurde sie bisher (zur Zeit der Veröffentlichung dieses Artikels) nur im Rahmen der Anwendung eingesetzt für welche die Bibliothek geschrieben wurde.

Zur Illustration ist die Bibliothek durch eine Demo-Anwendung und eine entsprechenden Makefile Datei ergänzt.

Die Anzeige von Test- und Fehlermeldungen beruht auf der Ausgabe an stdout und verwendet die Programme in der Datei Uart.c (Teil der Demoanwendungen der AVR-Libc) - mit zwei kleinen Anpassungen:
(1) es wird das Bestehen des zweiten seriellen Kanals im AT90CAN berücksichtigt,
und (2) die Warteschleife im Unterprogramm UartPutchar ist durch den Aufruf der "Idle-Loop" der Demo-Anwendung ersetzt. Damit ist die Verwendung auch bei aktivem Interruptsystem möglich - allerdings muss man Sorge tragen, dass zu jeder Zeit höchstens eine Ausgabe an stdout erfolgt.

==Elemente der CAN Bibliothek==

===Unterprogramme und globale Variable===

Die Bibliothek verwendet eine globale Variable - ''can_status'', welche in der Datei Can.c definiert ist. Sie dient vor allem der Synchronisation zwischen Interrupt Behandlung und Anwendungsprogramm.

Die wesentlichen Aufgaben werden von vier Unterprogrammen besorgt:

: '''CanInit''' initialisiert die Kontrolleinheit des AVR Prozessors und die Variablen der Programmbibliothek,
: '''CANIT_vect''' bedient CAN-relevante Interrupts,
: '''CanGetFrame''' behandelt den Empfang von Nachrichten,
: '''CanSendFrame''' besorgt das Senden von Nachrichten.

Weitere Unterprogramme sind:

: '''CanCheckWait''' hilft zu erkennen, wann das Senden einer Nachricht exzessiv lange dauert (z.B. weil kein Busteilnehmer antwortet),
: '''CanKillFrame''' erlaubt solche Nachrichten zu annullieren,
: '''CanNormalID''' und '''CanExtendedID''' dienen der Behandlung der Adressen und von Filtern; diese beiden Programme sind nur innerhalb von CanInit aufrufbar.

Alle diese Unterprogramme sind im Modul Can.c implementiert. Modul Can.h definiert die entsprechenden Datenstrukturen und Konstanten.

===Datenstrukturen===

Die folgenden Strukturen sind für die Programmierung der Anwendung von besonderer Bedeutung:

'''Die Struktur can_header''' dient zur Beschreibung einer zu sendenden oder gerade empfangenen Nachricht:
* '''mob_header''' = die Adresse der Nachricht - als 32-Bit binärer Wert dargestellt,
* '''mob_stamp''' = die Zeit (10 msec Einheiten) bei Eintreffen des die Nachrichten betreffenden Interrupts (Nachricht vollkommen empfangen, resp. Senden der Nachricht abgeschlossen),
* '''mob_length''' = die Zahl Bytes im Datenbereich der Nachricht,
* '''mob_flags''' = eine Liste von Bits zur Beschreibung der Eigenschaften des MOb:
** CAN_EXTD = wenn dieses Bit gesetzt ist, werden erweiterte, andernfalls normale Adressen verwendet.
** RTRTAG, RB0TAG, RB1TAG ... siehe AT90CAN Datenblatt,
* '''mob_page'''= der Index (0 bis 14) des die Nachricht enthaltenden MOb.
: Die Speicherung der Daten erfolgt unabhängig von dieser Struktur: die Speicherzone für die Daten wird beim Aufruf von ''CanSendFrame'' und ''CanGetFrame'' als eigenes Argument angegeben; dadurch können für die Beschreibung des MOb und der Daten Variablen mit unterschiedlicher Lebensdauer verwendet werden.

'''Die Struktur can_descr''' beschreibt den Zustand der CAN Kontrolleinheit:
* '''cs_stamp''' = eine Tabelle (15 Einträge - einer pro MOb) mit dem Zeitpunkt, bei dem das Senden eines MOb ausgelöst wurde (= Wert des oberen Bytes von CANTIMH),
* '''cs_rcvOK''' = eine 16-Bit Liste mit Bits zur Markierung von MObs, für welche die Anwendung den Empfang einer neuen Nachricht behandeln muss (0 wenn keine),
* '''cs_xmtOK''' = eine 16-Bit Liste mit Bits zur Markierung von MObs, für welche die Anwendung das Ende des Sendens behandeln muss (0 wenn keine),
* '''cs_mask''' = eine 16-Bit Liste mit Bits zur Markierung von MObs, die für das Senden reserviert sind,
* '''cs_xmit''' = der MOb Index des ersten MOb welches für das Senden reserviert ist (redundant zu cs_mask),
* '''cs_error''' = der Fehlerkode beim letzten Interrupt.

'''Die Struktur can_filter''' dient zur Definition der Filterdaten bei der Initialisierung eines MOb. Dies erlaubt bei der Initialisierung der Kontrolleinheit die für den Empfang bestimmten MObs auf einfache Weise zu definieren; die vier Elemente der Struktur sind:
* '''cf_idt''' = bestimmt die Adressen, die dem MOb zugeordnet sind, dargestellt als 32-Bit binärer Wert,
* '''cf_mask''' = die Liste der bei dieser Definition signifikanten Bits,
* '''cf_iflags''' = die Liste von Werten der Bits zur Beschreibung der Eigenschaften des MOb, die beim Filtern beachtet werden,
* '''cf_mflags''' = die Liste der bei dieser Definition signifikanten Bits.

: Die mit cf_iflags und cf_mflags zu definierenden Bits sind:

:: - '''CAN_EXTD''' = erweiterte oder normale Adressen verwenden, je nachdem ob dieses Bit gesetzt ist oder nicht,
:: - '''RTRTAG, RB0TAG, RB1TAG''' ... siehe AT90CAN Datenblatt,
:: - '''RTRMSK, RB0MSK, RB1MSK''' ... siehe AT90CAN Datenblatt.

: Wenn das Unterprogramm ''CanInit'' ein Filter einrichtet, werden die binären Werte aus cf_idt und cf_mask in Felder zerlegt und in den Registern CANIDT1 ... CANDIT4, bzw. CANIDM1 ... CANDIM4 gespeichert. Die Bits aus cf_iflags und cf_mflags werden dabei in die dem Namen der Symbole entsprechenden Positionen von CANIDT4, bzw. CANIDM4 gesetzt.

: Das Bit '''CAN_EXTD''' spielt eine etwas eigene Rolle:
:: - sein Wert wird zwar nur in cf_mflags angegeben, es steuert aber die Behandlung der meisten von ''CanInit'' behandelten Werte:
:: - es bestimmt das Format, nachdem die Werte aus cf_idt und cf_idm in Felder zerlegt werden;
:: - ausserdem bestimmt es, ob das IDE Bit im Register CANCDMOB gesetzt wird oder nicht.

===Konstanten und Parameter===

Die Bibliothek verwendet die Symbole für die Bezeichnung von Registern und Bits der Kontrolleinheit wie sie im ATMEL Datenblatt definiert sind - sie werden automatisch von AVR-Libc eingeführt; Can.h definiert zwei zusätzliche Symbole und deren Werte:
* '''CAN_EXTD''' bestimmt, ob ein Filter, resp. eine zu sendende Nachricht den normalen Adressbereich (V2.0 part A) oder den erweiterten Adressbereich (V2.0 part B) verwendet,

* '''MG_PRIORITY''' bestimmt ein Bit (binäre Maske) zur Kontrolle der Priorität beim Senden: Nachrichten, in deren Adresse dieses Bit gesetzt ist, haben geringere Priorität als solche, bei denen das Bit den Wert 0 hat (der Wert von MG_PRIORITY ist ein binärer Wert, nicht der Wert der dann in den Registern der Kontrolleinheit abgesetzt wird - siehe die Umwandlung in den Unterprogramme ''CanNormaID'' und ''CanExtendedID'').
: ''MG_PRIORITY'' steuert sowohl die Priorität bei der Wahl des zu sendenden MOb - wenn mehr als eines in der Kontrolleinheit wartet (Auswahl durch das Programm ''CanSendFrame''), als auch die Priorität beim Behandeln von Kollisionen am Bus (CAN arbitriert hierbei nach Massgabe der numerischen Werte der Adressfelder).

Die in die Register CANBT1, CANBT2, CANBT3 programmierten Werte müssen der Taktrate am Bus entsprechen (100Kbps im Original der Bibliothek); der Inhalt des Registers CANTCON bestimmt den internen Takt der Kontrolleinheit - er wird nur für den Mechanismus der Erkennung von hängengebliebenen Nachrichten beim Senden verwendet.

Falls der Wert von CANTCON oder die Echtzeit-Uhr anders definiert werden als im Original der Bibliothek, muss auch die Schwelle zum Erkennen von beim Senden zu lange wartenden MObs entsprechend geändert werden - siehe Kommentar im Unterprogramm ''CanCheckWait''.

==Unterprogramme der CAN Bibliothek==

Die einzelnen Unterprogramme sind reichlich kommentiert, der folgende Text beschränkt sich daher auf ergänzende Kommentare.

===CanInit===

Der erste Abschnitt (Initialisierung des MObs) definiert die Filter für den Empfang von Nachrichten. Die Angaben hierfür werden als Argumente beim Aufruf von ''CanInit'' festgelegt: das erste Argument ist eine Tabelle mit Definitionen für die Filter (im Flash-Speicher programmiert!) und das zweite die Zahl der zu definierenden Filter (wenn diese Zahl 0 ist, definiert ''CanInit'' automatisch ein einziges Filter, das für den Empfang aller Nachrichten dient). Der Index in der Tabelle entspricht dem Index des zu definierenden MOb in der Kontrolleinheit. MObs mit Indizes jenseits der so festgelegten Werte werden für das Senden von Nachrichten verwendet.

Bei der Definition von Filtern ist zu beachten, dass immer ein letztes Filter zum Empfang aller bis dahin nicht erkannten Nachrichten vorgesehen werden sollte (siehe Datenblatt des AT90CAN, Abschnitt 33.2 - "Errata", Paragraph 6).

===ISR CANIT_vect===

Dies ist das Programm zum Abarbeiten der von der CAN Kontrolleinheit erzeugten Interrupts. Folgende Interrupts werden behandelt:

: Interrupt nach Vollendung des '''Sendens einer Nachricht''':
:: Das Interrupt wird gelöscht, das MOb wird für neue Verwendung freigegeben. Das Bit mit dem Index des betroffenen MOb wird in der Kontrollvariablen ''can_status.cs_xmtOK'' gesetzt - damit wird das Ereignis der "Idle-Loop" des Anwendungsprogrammes gemeldet.

: Interrupt wenn einer '''empfangene Nachricht''' verfügbar ist:
:: Das Interrupt wird gelöscht, das MOb mit der empfangenen Nachricht wird bis zur Behandlung durch die Anwendung (Abholen der Empfangenen Daten) blockiert. Das Bit mit dem Index des betroffenen MOb wird in der Kontrollvariablen ''can_status.cs_rcvOK gesetzt'' - damit wird das Ereignis der "Idle-Loop" des Anwendungsprogrammes gemeldet.

: Interrupt zufolge eines '''Fehlers''':
:: Derzeit im Programm noch nicht unterstützt, nur das Interrupt wird gelöscht.

===CanSendFrame===

''CanSendFrame'' löst das Senden einer Nachricht durch die Kontrolleinheit aus (das Ende des Sendevorganges wird aber nicht abgewartet). Falls - z.B. wenn Nachrichten hintereinander und in einer garantierten Reihenfolge gesendet werden sollen - das Ende abgewartet werden muss, ist dies Aufgabe der Anwendung (dazu dient z.B. das Unterprogramms ''XmitWait'', siehe Demo-Anwendung).

Wichtige Abschnitte des Programms:
* Wahl eines verfügbaren MOb
: Die Kontrolleinheit des AT90CAN entscheidet bei Vorliegen mehrerer zu sendender Nachrichten welche Nachricht mit Priorität zu behandeln ist: die Nachricht in dem MOb mit dem jeweils niedrigsten Index wird als erste gesendet.

: Der Mechanismus zur Wahl des zu verwendenden MOb baut auf dieses Verhalten: das Abtasten zum Finden des ersten verfügbaren MObs beginnt bei dem niedrigsten MOb wenn der Wert des Bits in der Position MG_PRIORITY 0 ist, sonst bei dem MOb mit dem höchsten Index (Index 14).

* Setzen der IDT Register
: Der binäre Wert in ''p_header.mob_ID'' wird in die entsprechenden Werte für die IDT Register umgesetzt, wobei die unterschiedlichen Formate für die beiden Varianten der Adressierung berücksichtigt werden; der Vorgang hierbei ist analog zu dem, was in der Beschreibung der Datenstruktur ''can_filter'' erklärt ist.

* Auslösen des Sendevorgangs
: Die Daten werden vom Anwendungsbereich in die Register der Kontrolleinheit kopiert - danach sind die als Argumente für den Aufruf von ''CanSendFrame'' verwendeten Speicherzonen wieder verfügbar. Der Zeitpunkt des Sendens wird in ''can_status.cs_stamp'' (indiziert mit dem Index des MOb) gespeichert - dies ist der zu diesem Zeitpunk in CANTIMH befindliche Wert; er dient als Grundlage für das Programm ''CanCheckWait'' um MObs zu finden, die "hängen" geblieben sind (der häufigste Grund dafür ist das Fehlen eines Partners am Bus, der Nachrichten mit der entsprechenden Adresse quittiert).

===CanGetFrame===

''CanGetFrame'' geht davon aus, dass die Ankunft einer Nachricht schon bei der Behandlung der Interrupts erkannt und behandelt wurde. ''CanGetFrame'' wird daraufhin aufgerufen um die Daten abzuholen (bei der Behandlung des Interrupts wurde das MOb gegen eine versehentliche neue Verwendung geschützt).

Das Programm kopiert danach (a) die wesentlichen Daten aus dem Nachrichten Kopf und (b) die Nachricht selber in die von der Anwendung bestimmten Speicherzonen. Danach wird das MOb wieder freigegeben.

=== CanCheckWait und CanKillFrame===

''CanCheckWait'' ist ein Unterprogramm, das von der Anwendung periodisch aufgerufen werden sollte, wenn nichts anderes zu tun ist. Bei jedem Aufruf wird zyklisch ein MOb untersucht und darauf geprüft, ob und wie lange es mit dem Senden einer Nachricht beschäftigt ist (Vergleich des Werts in ''can_status.cs_stamp'' und mit dem jeweiligen Wert von CANTIMH). Im Kode von ''CanCheckWait'' ist eine Schwelle definiert, deren Überschreiten als Fehler behandelt wird.

Die statische Variable ''next_mob'' in ''CanCheckWait'' bestimmt, welches MOb als nächstes zu Prüfen ist - sie wird nach jedem Aufruf neu definiert.

Das Programm ''CanKillFrame'' dient dazu, den Sendevorgang eines dermassen gefundenen MOb abzubrechen.

Die globale Variable ''killed_mobs'' (sie gibt es erst ab Version V1.0.1) informiert über MObs, deren Senden mithilfe von CanKillFrame abgebrochen wurde. Sie ist anfänglich auf 0 gesetzt; wenn CanKillFrame eine MOb re-aktiviert, wird das entsprechende Bit gesetzt. Eine Anwendung kann einzelne / alle Bits wieder löschen nachdem sie den Sachverhalt zur Kenntnis genommen hat.

Solch ein Sendeabbruch muss nicht unbedingt als Hinweis auf einen zu korrigierenden Fehler verstanden werden: beim Hochfahren einzelner / aller Netzknoten kann es vorkommen, dass Nachrichten versendet werden, bevor ein adressierter Partnerknoten aktiviert ist.

==Demo-Anwendung==

Die Demo-Anwendung erlaubt die Verwendung der CAN Bibliothek unter einfachen und erprobten Bedingungen.

===Echtzeitrahmen===

Das dabei eingesetzte Prinzip ist einfach:
* der Prozessor durchläuft eine Endlos-Warteschleife - die "Idle-Loop"; nach jedem Durchgang wird der Prozessor in den "Sleep" Zustand gesetzt;
* die Behandlung von Interrupts definiert "Ereignisse" - deren Eintreffen markiert eine zur Synchronisation vorgesehene Variable; als Folge des Interrupts wird die Warteschleife neu durchlaufen;
* jeder Durchgang durch die Endlos-Warteschleife prüft die zur Synchronisation bestimmten Variablen und erkennt, wenn eine Variable gesetzt ist: in der Folge wird alles unternommen, was für das Abarbeiten des Ereignisses nötig ist, und die Variable wird gelöscht.

Dieses Prinzip kann auch zur Gestaltung eines minimalen Echtzeitrahmens für einfache Anwendungen verwendet werden, was den Einsatz eines Echtzeit-Betriebsystems erübrigt. Ich verwende, zum Beispiel, dieses Konzept bei meiner Hausbus Anwendung.

Damit dieses Vorgehen klaglos funktioniert sind zwei wichtige Punkte zu beachten:
# In der gesamten Anwendung dürfen keine "busy-wait" Warteschleifen (= von Interrupts nicht unterbrechbare Schleifen) programmiert sein - wie sie z.B. in den in <util.delay.h> und <util/delay_basic.h> definierten Werkzeugen der AVR-Libc Bibliothek vorkommen; dies ist auch der Grund, warum im Uart.c Programm der AVR-Libc Bibliothek eine kleine Änderung notwendig ist.
# Iterative Aufrufe der Programme der "Idle-Loop" sind sorgfältig zu programmieren: solche Aufrufe erzeugen zusätzliche Niveaus der Warteschleife und reservieren dabei jeweils alle dafür nötigen lokalen Variablen; ein typisches Beispiel dafür ist, wenn beim Abarbeiten des Empfangs einer Nachricht eine neue Nachricht mit ''CanSendFrame'' gesendet wird und dann das Unterprogramm ''XmitWait'' aufgerufen wird.

: Die Variable ''idle_level'' der Demo-Anwendung gibt jederzeit die Zahl aktiver "Idle-Loops" an.

Diese "'''Verschachtelung der Aufrufe'''" von Warteschleifen ist das '''kritische Element''', das bei der Entscheidung zwischen dem Einsatz der hier beschriebenen Methode und dem Einsatz eines Echtzeit Betriebsystems zu bewerten ist:

* Bei einer Demo-Anwendung zum Erproben der Bibliothek, oder bei einer einfachen Anwendung wie meinem Hausbus (ich habe nie mehr als 2 Niveaus von Warteschleifen) ist diese Methode hervorragend geeignet.

* Bei einer komplexen Anwendung, wo die Zahl der Niveaus hoch oder unvorhersehbar ist, kann der Einsatz dieses Konzepts problematisch werden.

Diese kritische Bemerkung betrifft natürlich nur die Demo-Anwendung, die CAN Programmbibliothek kann ohne Einschränkung sowohl mit einem Echtzeit Betriebssytem als auch mit der einfachen Warteschleifen Methode eingesetzt werden. Bei Einsatz eines Echtzeit Betriebssystems wird es aber wahrscheinlich nötig sein, im Unterprogramm CANIT_vect den Mechanismus für die Kommunikation mit dem Betriebssystem den Anforderungen des gewählten Systems anzupassen.

===Elemente der Demo-Anwendung===

Die wesentlichen Bestandteile der Demo-Anwendung sind:
* eine '''Warteschleife''' ("Idle-Loop") - nach Ende jeder Iteration geht der Prozessor in den "Sleep" Zustand,

* ein interruptgetriebener '''Taktgeber''' (''Timer'') mit 10 msec Intervallen, der die Warteschleife periodisch aktiviert und jeder Aktivierung das auslösende Ereignis beiordnet; vom Taktgeber generierte Ereignisse sind: (a) 10-msec Interrupts, (b) 1-sec Echtzeit Zähler-Schritte, und (c) der Ablauf einer vorgewählten Warte-Periode (Unterprogramm ''TimedWait''),

* Erweiterungen der "Idle-Loop" zum '''Abarbeiten''' der bei der Interrupt Behandlung '''markierten Ereignisse''' (zusätzlich zu den vom Taktgeber erzeugten Ereignissen natürlich auch zum Abarbeiten der weiter oben beschriebenen Ereignisse der CAN Kontrolleinheit),

* zwei '''Hilfsprozeduren''': ''XmitWait'' zum Warten auf die Vollendung des Sendens einer Nachricht (mit aktivierten Interrupts), und ''TimedWait'' zum Warten einer festgelegten Zeit (mit aktivierten Interrupts); ''TimedWait'' ist hier nur zur Illustration erwähnt, das Unterprogramm wird im Demobeispiel nicht verwendet.

Diese Unterprogramme sind im Modul Demo.c enthalten, in Demo.h werden alle global verwendbaren Definitionen vorgenommen.

===Kommentare zum Hauptprogramm (main)===

Das Programm erklärt sich im wesentlichen selbst: nach der Initialisierung startet das Hauptprogramm den "Watchdog Timer" (die "Idle-Loop" unternimmt alle Sekunden die nötigen periodischen Watchdog Aufrufe); danach wird eine Initialisierungszeile gedruckt und eine Nachricht auf den CAN Bus gelegt.

Der Aufruf von ''CanInit'' erfolgt im hier gezeigten Beispiel in einer vereinfachten Form: der Wert 0 des zweiten Arguments bedeutet, dass die Anwendung keine Filter definiert: das Programm ''CanInit'' erzeugt automatisch ein Default Filter, das die Kontrolleinheit alle Nachrichten in einem einzigen MOb empfangen lässt.

Schliesslich durchläuft das Programm die "Idle-Loop".

===Kommentare zum Unterprogramm IdleActions===

Die Kontrollvariablen werden der Reihe nach auf das Vorliegen der verschiedenen Ereignisse abgefragt: wenn eine Ereignis-Variable (hier ein Bit in den Variablen ''can_status.cs_xmtOK'', ''can_status.cs_rcvOK'' oder ''interrupt_flags'') bei der Behandlung eines Interrupts markiert worden ist, wird das entsprechende Ereignis abgearbeitet, die Markierung wird gelöscht.

Die spezifischen Aktionen bei den einzelnen Ereignissen sind im folgenden kurz beschrieben.
: Ablauf der vorgewählten Warte-Periode:
:: Falls ''IdleActions'' vom ''TimedWait'' Unterprogramm aufgerufen wurde, Rückkehr zu diesem Unterprogramm - sonst keine Aktion.

: Echtzeit-Zähler Sekundenschritt:
:: Sekundenzähler nachführen, "Watchdog Timer" aufrufen.

: Empfang einer Nachricht vom CAN Bus:
:: Die Kontrollvariable ''can_status.cs_rcvOK'' enthält die Liste aller MObs (Liste von Bits), für die eine empfangene Nachricht wartet. Das Bit mit der höchsten Priorität in die Nummer (Nummern 0 ... 14) des entsprechenden MOb umwandeln, ''CanGetFrame'' für dieses MOb aufrufen, eine entsprechende Zeile drucken.

: Abschluss des Sendens einer vom CAN Bus gesendeten Nachricht:
:: Falls ''IdleActions'' vom ''XmitWait'' Unterprogramm aufgerufen wurde, Rückkehr zu diesem Unterprogramm - sonst keine Aktion.

: Andere Ereignisse (10 msec Taktgeber Ereignis):
:: Prüfen ob eine "hängengebliebene" Nachricht existiert und gegebenenfalls Löschen dieser Nachricht. Danach den Prozessor in den "Sleep" Zustand setzen.

Die Befehlsfolge am Ende des Unterprogramms bezweckt, dass der Prozessor sicher und ohne Auslösen eines Interrupt sofort nach dem "sei" Befehl in den "Sleep" Zustand gesetzt wird - wie in der Dokumentation zu avr/sleep.h (AVR-Libc) beschrieben:

<avrasm>
cli () ;
sleep_enable () ;
sei () ;
sleep_cpu () ;
sleep_disable () ;
</avrasm>

Dadurch wird sichergestellt, dass ein neuer Durchlauf durch die Warteschleife erfolgt, auch wenn ein Interrupt genau am Ende der Warteschleife erfolgt.

===Kommentare zu den Unterprogrammen XmitWait und TimedWait===

Mithilfe dieser Unterprogramme kann die Anwendung das Eintreten eines Ereignisses abwarten, ohne dass dafür eine "busy-wait" Schleife programmiert werden muss.

''XmitWait'' startet eine neue Warteschleife und bleibt darin, bis das Senden der als Argument angegebenen MOb beendet ist. ''TimedWait'' startet eine neue Warteschleife und bleibt darin, bis die als Argument von ''TimedWait'' vorgegebene Zahl von 10-msec Intervallen abgelaufen ist.

Alle auftretenden Ereignisse werden von der jeweils ausgeführten Warteschleife abgearbeitet (das ist die Warteschleife, die als letzte geöffnet wurde).

==Adressierung und Filter==

===Verwendung von CanInit zum Definieren von Filtern===

Zum leichteren Verständnis verzichtet die oben beschriebene Demo-Anwendung auf den Einsatz von Filtern.

Die folgenden Bemerkungen illustrieren, wie Filter verwendet werden können und sollen Anregungen sein, wie das Broadcast Konzept von CAN für die Bestimmung der Partner beim Austausch von Nachrichten sinnvoll eingesetzt werden könnte.

Die beiden Argumente von ''CanInit'' erlauben, eine Tabelle mit Filtern zu definieren, welche dann von ''CanInit'' installiert werden. Wenn diese Tabelle in der Variablen ''filter_table'' definiert ist (sie muss im Flash Speicher liegen), sieht der Aufruf von CanInit so aus:

<avrasm>
CanInit ( filter_table, sizeof (filter_table) / sizeof (can_filter) ) ;
</avrasm>

===Konzept für die Gestaltung des Adressraums, Beispiel===

Bevor eine Filtertabelle erstellt wird, muss ein Konzept für die Gestaltung des Adressraums definiert werden. Im hier erläuterten Beispiel wurde das folgende Konzept gewählt:

'''Normale Adressen''' (11-Bit Werte) werden in zwei Zonen zerlegt:
* die oberen 3 Bits bestimmen eine Adress-Familie,
* die unteren 8 Bits unterscheiden spezifische Adressen innerhalb einer Familie,
* das oberste der 3 Bits in der ersten Zone teilt die Familien in 2 Gruppen - eine Gruppe mit hoher Priorität beim Senden, eine mit niedriger Priorität; die unteren 2 Bits definieren damit 4 Gruppen, die mit und ohne Priorität verwendet werden können (siehe auch die Beschreibung des '''MG_PRIORITY''' Bits im Abschnitt Datenstrukturen).
* im Modul Can.h werden Symbole mit Werten für die Familien definiert, z.B.:
<avrasm>
#define MG_MASK 0x0700L // message group mask
#define MG_PRIORITY 0x0400L // priority bit (set if low priority)

#define MG_BROADCAST 0x0400L // low-priority broadcast
#define MG_ACTION 0x0500L // low-priority action trigger
#define MG_MODIFY 0x0600L // low-priority modify state request
</avrasm>
* auch für die unteren 8 Bits ist es zweckmässig, Symbole zu definieren - hier sind ein paar Beispiele für Typen von Broadcast Nachrichten die ich verwende:
<avrasm>
enum {
MB_TIME = 1, // sending time and date
MB_POLL, // CPU status poll
MB_ECHO, // CPU status echo
MB_CONFIG, // Solicit configuration messages
...
} ;
</avrasm>

Auch '''erweiterte Adressen''' können in mehrere Zonen zerlegt werden - damit lässt sich Kontrollinformation im Nachrichtenkopf "verstecken" ohne die wertvollen 8 Datenbytes zu verwenden:
* Sequenznummer der Nachricht,
* Typ der Nachricht,
* Zieladresse.

Ich habe vorgesehen (es aber bisher nicht gebraucht und daher noch nicht implementiert) dies für verbindungs-orientierte Kommunikation zu verwenden. Zurzeit setze ich erweiterte Adressen ein, um eine Nachricht an eine spezifische CPU zu senden und dabei zwischen verschiedenen Arten von Nachrichten zu unterscheiden.

Die für eine derartige Verwendung des Adressraums nötige Programmierung ist Aufgabe der Anwendung: sie muss das ''mob_header'' Feld zum Senden entsprechend vorbereiten, bzw. beim Empfang entsprechend interpretieren - die CAN Bibliothek hat damit nichts zu tun, sie arbeitet auf einer tieferen "Schicht".

===Definition eines Satzes von Filtern, Beispiel===

Eine Definition der Filtertabelle kann dann so aussehen:
<avrasm>
// Can receive filter definition table
// -----------------------------------
// Filter table item descriptors for channel 0 and on
// Channels beyond those defined in this table are used for
// transmission

static can_filter filter_table[] PROGMEM = {
// tag mask tag_flags mask_flags

// high-priority broadcasts
{ MG_BROADCAST & ~MG_PRIORITY, MG_MASK, 0, _BV(RTRMSK) | _BV(IDEMSK) },

// low- & high-priority broadcasts
{ MG_BROADCAST & ~MG_PRIORITY, MG_MASK & ~MG_PRIORITY, 0, _BV(RTRMSK) | _BV(IDEMSK) },

// high-priority modify state requests
{ MG_MODIFY & ~MG_PRIORITY, MG_MASK, 0, _BV(RTRMSK) | _BV(IDEMSK) },

// low- & high-priority modify state req.
{ MG_MODIFY & ~MG_PRIORITY, MG_MASK & ~MG_PRIORITY, 0, _BV(RTRMSK) | _BV(IDEMSK) },

// extended messages (sequence numbers)
{ CPU_ID, 0x000000FFL, 0, _BV(RTRMSK) | _BV(IDEMSK) | CAN_EXTD },

// all other messages
{ 0x00000000L, 0x00000000L, 0, _BV(RTRMSK) } } ;
</avrasm>

Die ersten 4 Filter sind Paare von Filtern (je ein Filter mit hoher und mit niedriger Priorität) für die Gruppen mit Adressen der Familie MG_BROADCAST und MG_MODIFY, alle verwenden normale Adressen. Das fünfte Filter verwendet erweiterte Adressen und dient dem Empfang von Nachrichten nur für den betroffenen Prozessor (CPU_ID muss in Demo.h definiert sein). Das letzte Filter wird für den Empfang aller Nachrichten verwendet, die von den ersten 5 Filtern nicht angenommen worden sind.

==Links==

===Referenzdokumente===
Hier sind zwei Artikel: (a) spezifischen Fragen zum CAN Zugriff mittels AT90CAN Prozessoren, und (b) ein Tutorial zur praktischen Implementierung des Zugriffs auf einen CAN Bus von einem AVR Prozessor - auch wenn er den AT90CAN "umgeht" ist er eine hervorragende Einführung zu Fragen der praktischen Implementierung des Zugriffs von einem AVR Prozessor auf einen CAN Bus:
* [http://www.avrfreaks.net/modules/FreaksArticles/files/23/CAN%20on%20the%20AVR.pdf CAN on the AVR (Mike Blendermann)]
* [http://www.kreatives-chaos.com/artikel/ansteuerung-eines-mcp2515 Ansteuerung des MCP2515 (Tutorial, Fabian Greif)]

Daneben gibt es Tonnen von Artikeln zu CAN, die aufzuzählen hier fehl am Platze wäre.

===Dateien mit dem Quelltext der Bibliotheksprogramme===
* [http://cui.unige.ch/~harms/canlib/Can.c Can.c - V1.0.1, korrigiert 30.07.2009]
* [http://cui.unige.ch/~harms/canlib/Can.h Can.h]
* [http://cui.unige.ch/~harms/canlib/Demo.c Demo.c]
* [http://cui.unige.ch/~harms/canlib/Demo.h Demo.h]
* [http://cui.unige.ch/~harms/canlib/Uart.c Uart.c]
* [http://cui.unige.ch/~harms/canlib/Makefile Makefile]

:: '''[[CAN_Bibiliothek_f%C3%BCr_AT90CAN_Prozessoren#top|Zurück zum Inhaltsverzeichnis]]'''

[[Kategorie:AVR-Projekte]]
[[Category:CAN]]

Pollin Funk-AVR-Evaluationsboard

2009-09-25T14:55:34Z

84.58.239.213: /* 8-Bit Zähler mit RS232-Anschluss */ Layout

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

== 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]]

<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);
}
}
</c>

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

<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);
}
}
}

</c>

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

<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;
}
}

</c>

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

<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;
}
}
}

</c>

=== 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:

<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;
}
}
}

</c>

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.

<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++;
}
}

</c>

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.

<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

</c>

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

<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

</c>

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

<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);

</c>

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

<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");
}
}

</c>

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

<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

</c>

'''PFA_funkhw.h''' - Definitionen für das PFA ;-) Board
<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

</c>

'''PFA_rs232.c''' - Erweiterte rs232-Funktionen
<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;
}
}

</c>

'''PFA_rs232.h''' - Prototypen zu den rs232-Funktionen
<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

</c>

'''PFA_uart.c''' - UART Grundfunktionen (aus ehemaligem rs232.c herausgezogen)
<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

</c>

'''PFA_uart.h''' - Prototypen zu den UART Grundfunktionen
<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

</c>

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

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 Ohm [[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 Ohm 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).

<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

</c>

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

<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

</c>

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

<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

</c>

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

<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
</c>

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

<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
</c>

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

<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
</c>

'''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:

<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 Ohm => 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
</c>

=== 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()):

<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);
}
}
</c>

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

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.
<c>
#include <avr/io.h>
#include <avr/interrupt.h>
// #include <signal.h>
</c>
* Anpassen des Eingangspins für das Signal vom TSOP1736.
<c>
#define xRC5 PD2 // IR input low active (statt PD7)
</c>
* 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!
<c>
//#define XTAL 11.0592e6
#define XTAL 8e6 // Attiny2313 auf Pollin Funk AVR Board
</c>

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

'''Änderungen in rc5.c''':
* Einbau der DEBUG-LED. Dazu wird folgendes Codestück zwischen #if 1 und #endif ergänzt.
<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
</c>

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

== 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] und [http://www.mikrocontroller.net/topic/122551#1118124]
* [http://www.mikrocontroller.net/topic/147072#1369628 Pollin Funkboard mit Mega8, [[RFM12]], [[LCD]], [[DCF77]] und [[DS18S20]]]

== 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:Funk]]