Mikrocontroller.net - Benutzerbeiträge [de]

FPGA

2015-11-13T10:47:48Z

153.96.195.35:

FPGA ist die Abkürzung für "'''F'''ield '''P'''rogrammable '''G'''ate '''A'''rray".

== Aufbau ==

=== Grundelemente ===

Ein FPGA besteht, ähnlich wie ein [[CPLD]], aus vielen Logikelementen, hauptsächlich [[FlipFlop]]s (FF) und davor gelagerten kombinatorischen Logikschaltungen. Diese sind entweder Verknüpfungen verschiedener Logikgatter (FPGAs der Firma Actel), die über elektronische "Schalter" entsprechend der vom Entwickler gewünschten Funktion miteinander verknüpft werden können oder es handelt sich um sogenannte LUTs (Look-Up-Table), mit denen die Logikfunktion explizit realisiert wird.

Eine '''LUT''' kann eine beliebige kombinatorische Funktion (NAND, XOR, AND, Multiplexer etc.) aus den Eingangssignalen realisieren. Die Anzahl der Eingangssignale pro LUT ist vom FPGA abhängig und liegt meist zwischen 4 und 6. Für Funktionen die mehr Eingänge erfordern als eine einzige LUT besitzt (hohes Fan-In), werden mehrere LUTs direkt miteinander verschaltet. Die [[FlipFlop]]s dienen dazu, Signalwerte zwischenzuspeichern, um sie im nächsten Takt weiterverarbeiten zu können. Das Verhältnis zwischen der Anzahl der LUTs und der Anzahl der Flip-Flops ist meist 1:1. Aktuelle FPGAs bestehen aus bis zu einigen zehntausend Logikelementen.

Die logischen Schalter und Speicher sind in den meisten FPGAs durch [[Speicher#SRAM | SRAM]]-Speicherzellen realisiert, welche beim Bootprozess passend geladen werden. Das Laden dieser Konfigurationsdaten bzw. Verknüpfungsregeln geschieht dabei in der Regel aus einem speziellen [[Speicher#Flash | Flash-ROM]]-Baustein heraus. Es kann aber auch ein Mikrocontroller benutzt werden. Die meisten FPGAs bieten daher für diesen Konfigurationsvorgang mehrere Modi an (seriell, parallel, Master/Slave). Da die SRAM-Zellen ihren Inhalt beim Abschalten der Versorgungsspannung verlieren, muss ein SRAM-basierter FPGA bei jedem Einschalten neu konfiguriert werden. Daher benötigt ein solcher FPGA einige Millisekunden bis zu einigen Sekunden, bevor er voll betriebsbereit ist.

Eine FPGA-Familie beinhaltet Typen mit unterschiedlicher Anzahl und Komplexität von Logikzellen. So enthält ein Spartan3-1000 ca. 2,5 mal so viel Logik (FF, LUTs) wie ein Spartan3-400.

FPGAs mit nichtflüchtigem Speicher basieren auf [[Speicher#EEPROM | EEPROM]]-, [[Speicher#Flash | Flash]]-Speicher (einige Familien von Lattice und Actel) oder AntiFuse- Technologie (Actel). Die sogenannten AntiFuse FPGAs sind nur einmalig programmierbar.

=== I/O Anschlüsse ===

FPGAs unterstützen als universal einsetzbare Digital-ICs eine Vielzahl von Signalstandards. Üblich sind verschiedene TTL-Pegel (5V, 3,3V, 2,5V), differentielle Signalstandards (LVDS, GTL, GTP) und im Hochpreisbereich serielle Hochgeschwindigkeitsstandards mit bis zu 28 Gbit/s. Oftmals sind weitere Eigenschaften wie Treiberstärke und Flankensteilheit für jeden benutzerdefinierbaren Anschluss (User-IO) einstellbar. Meist sind die Pins zu Bänken mit gleichem I/O Standard zusammengefasst. Innerhalb einer solchen Bank arbeiten alle Pins im gleichen I/O Standard und mit der selben I/O Spannung. Für hohe Taktraten wird sowohl für Daten als auch die Takte der LVDS IO-Standard verwendet. Hier sind zwei komplementäre Buffer in unmittelbarer Nachbarschaft angeordnet. [[Ausgangsstufen Logik-ICs | Tristatebuffer]] werden implizit über VHDL definiert, indem einem Ausgang zeitabhängig der Zustand "Z" zugewiesen wird. Alternativ kann er explizit als Komponente eingefügt werden. Ebenso können je nach Hersteller und Typ interne Pull-Up und Pull-Down-Widerstände sowie Terminationswiderstände zugeschaltet werden, [[Wellenwiderstand | Terminierung]] wird ebenfalls unterstützt. Zudem befinden sich hinter vielen IO-Pads sog. [[Boundary_scan| Boundary Scan]] Zellen. Bei komplexeren FPGAs sind die Ein- und Ausgänge mit Verzögerungsgliedern versehen, die ein Anpassen des Timings bei Bussen wie z.B. schnellen Speichern ermöglichen. Einige Pins übernehmen besondere Funktionen und sind somit vom Anwender nicht uneingeschränkt oder z.T. auch gar nicht nutzbar. Dazu zählen neben der [[JTAG]]-Schnittstelle z. B. die Pins zum Einlesen der Konfigurationsdaten. Ferner sind einige wenige Pins (2 - 8) zum Einspeisen des Taktes für das Design vorgesehen. Für schnelle Schaltungen sollten diese reservierten Pins benutzt werden. Sie enthalten kein Eingangs-FF und wirken über instanziierbare Buffer direkt auf Taktnetze / PLLs. Bei leistungsfähigen grossen Applikationen mit mehreren Takten müssen diese genutzt werden, da nur eine begrenzte Zahl von DCMs (Digital Clock Manager) zur Verfügung steht und benachbarte IO-Pins genutzt werden müssen. Für hohe Taktraten werden LVDS-Eingänge verwendet. Das I/O Verhalten wird zusammen mit vielen anderen Parametern in einer Datei festgelegt (Xilinx *.ucf, Altera *.acf, Lattice *.lpf). Alternativ können diese auch als Syntheseoption im Kommentarfeld des [[Verilog]]/[[VHDL]] Codes mit angegeben werden. Die Hersteller bieten FPGAs mit gleicher Anzahl von Logikelementen in unterschiedlichen Gehäusen an. So kann der FPGA mit der passenden Anzahl von Pins eingesetzt werden. Das obere Ende markieren Chips mit über 1500 I/Os, die kleinsten bieten ca. 50 User-I/O. Oft werden nur [[IC-Geh%C3%A4useformen#BGA|BGA]] und [[IC-Geh%C3%A4useformen#QFP|QFP]] Gehäuse (bis ca. 240 Pins) angeboten. Umgekehrt kann innerhalb einer Gehäusefamilie hochmigriert werden, d.h. bei gleichbleibendem Pinout, kann ein komplexerer FPGA eingesetzt werden. Das Layout muss dann nicht verändert werden, um eine Schaltung mit mehr Funktionen auszustatten.

=== Komplexe Funktionsblöcke ===

Neben den einfachen FlipFlops beinhalten FPGAs darüber hinaus komplexe Routing- und Speicherkonfigurationsoptionen innerhalb und außerhalb der logischen Elemente (LEs), die es gestatten, komplexe Schalt- und Rechenstrukturen aufzubauen. Für rechenintensive Designs, z. B. in der Signalverarbeitung, enthalten viele FPGAs '''Multiplizierer''' direkt auf dem Chip, die in einem einzigen Taktzyklus Multiplikationen durchführen können.

Ferner haben FPGAs oft einen von den LEs getrennt verfügbaren '''RAM'''-Bereich integriert, der sich in vielfältiger Weise ansprechen lässt. So können damit Single- oder Dualport-RAMs mit variabler Bitbreite erzeugt werden. Üblich sind mehrere (4 - 30) kleinere Dualport [[Speicher#BRAM | RAM-Blöcke]] von 4 - 16 kbit. Einige Familien besitzen einen größeren internen RAM, andere spezielle FIFO-Blöcke.

Zur Generierung spezieller Takte sind '''PLL'''s (Phase Locked Loop) auf dem FPGA integriert. Einige Hersteller setzen mit dem selben Ziel '''DLL'''s (Delay Locked Loop) ein. Mittels dieser Blöcke können aus einem Taktsignal weitere erzeugt werden. Typisch sind Taktverdopplung oder -vervielfachung. Ebenso kann der Takt geteilt werden oder ein Signal gleicher Frequenz, aber um eine halbe, viertel usw. Periode verschoben erzeugt werden. Typische Anwendungen sind die Ansteuerung von [[Speicher#DDR-RAM | DDR-RAMs]] oder die Kompensation von Laufzeitunterschieden zwischen Takt und mit diesem getakteten Steuersignalen. Meist sind 2 - 8 Taktnetzwerke und PLL/DLLs gleicher Anzahl integriert. Siehe auch [[Taktung FPGA/CPLD]].

=== CPU im FPGA ===

Programmierbare Prozessoren sind auch in FPGA-Designs immer häufiger anzutreffen. CPUs sind zwar im Allgemeinen langsamer und weniger effizient, als eine vollständige Implementation aus Logik-Primitiven - aber bei komplexen Abläufen auch deutlich einfacher und zielführender zu programmieren, da die Strukturen festgelegt und damit bekannt sind. Insbesondere bei sequentiellen Aufgaben (Benutzerinterface, komplexe Steueraufgaben etc.) wird man gerne auf eine klassische CPU zurückgreifen. Die CPUs sind teilweise kompatibel zu etablierten Prozessorarchitekturen (MIPS, SPARC, AVR), zum Teil aber auch auf die FPGAs einzelner Hersteller hin optimiert.

Als Programmspeicher werden die FPGA-internen [[Speicher#BRAM | RAM-Blöcke]] oder externe [[Speicher]] (SDRAM, SRAM) genutzt. Für einige Prozessorkerne stehen Hochsprachen wie C, C++ etc. zur Verfügung, andere werden in Assembler programmiert.

==== Hardcores ====
Manche FPGAs haben dazu einen oder mehrere Prozessorkerne (z. B. [[AVR]] bei Atmels FPSLIC, PowerPC bei Xilinx' Virtex bzw Dual ARM A9 bei Xilinx' Zynq oder ARM Cortex-M3 bei Actel (Microsemi) SmartFusion ) als ''HardCores'' physikalisch auf dem Chip integriert, entweder als Chipstruktur auf dem FPGA-kern selbst oder als gebondeter Chip im selben Gehäuse.

==== Softcores ====
Auf der anderen Seite gibt es auch [[FPGA Soft Core | SoftCores]] (z. B. ARM-Cortex-M1 bei IGLOO-FPGA von [http://www.actel.com ACTEL]), Prozessorkerne die als Quelltext oder als vorsynthetisierte Netzliste vorliegen. In Abhängigkeit von den zur Verfügung stehenden Ressourcen können diese ''SoftCores'' beliebig instanziiert werden. Es gibt eine Vielzahl verschiedener ''SoftCores''. Einige sind sehr klein und platzsparend realisiert, damit kann man auch auf vergleichsweise kleinen aktuellen FPGAs problemlos eine 32bit-RISC-CPU integrieren.

== Eigenschaften ==

=== Chipausnutzung ===
Aufgrund des Umstandes, dass FPGAs eine Reihe von allgemeinen Funktionsblöcken, wie BRAM, Multipliers, Transceivern beinhalten, die naturgemäß nie voll ausgenutzt werden können und zudem viele Routing-Resourcen benötigen, um die gewünschten Verschaltungen zu ermöglichen, nutzen FPGAs die Chipfläche relativ schlecht aus, was zu entsprechende geringer finanzieller Effizienz führt.

=== Taktgeschwindigkeit ===
Die maximale „Geschwindigkeit“ eines FPGAs ist von der verwendeten Halbleitertechnologie (Prozess, Strukturgrößen), der internen Schaltungstopologie (Komplexität der LEs), Vorhandensein von harten Strukturen und vor allem vom Design abhängig. Dabei sind der sogenannte Datendurchsatz und die rein maximale Systemtaktfrequenz zu unterscheiden. Die erreichbare Taktfrequenz lässt sich ohne detaillierte Kenntnis des Designs nicht abschätzen, möglich sind je nach »Speed Grade« des ICs typischerweise Taktfrequenzen von 300-600 MHz für die Schaltgeschwindigkeit der reinen Logikelemente. Je nach der Anzahl und Komplexität der pro Takt durchzuführenden Operationen ergeben sich dann reale Systemtaktfrequenzen von meist 10-100 MHz für global operierende Einheiten und bis zu 300 MHz für schnelle lokale Module. Maßgeblich ist in wieweit das Design auf Fläche bzw. Geschwindigkeit hin optimiert und vom Tool synthetisiert wurde: Durch das Einbringen von zusätzlichen Registerstufen lassen sich z. B. zeitkritische Pfade entschärfen (Pipelining), sodass die Frequenz des Chips angehoben werden kann und somit der effektive Datendurchsatz erhöht wird, mit dem Nachteil der gesteigerten Latenz durch das Mehr an Takten. Der Datendurchsatz lässt sich darüber hinaus durch die Nutzung paralleler Architekturen verbessern.

Die Systemfrequenz kann-, muss aber nicht der Frequenz entsprechen, mit der Daten zyklisch eingetaktet und verarbeitet werden; zudem sind Schaltungsteile mit unterschiedlichen Taktfrequenzen zu unterscheiden: Mit einem Systemtakt von 20 MHz lassen sich z. B. 18-Bit AD-Wandler auslesen, die so z. B. alle 1 µs neue Daten liefern, die verarbeitet werden müssen. Bei der Nutzung von 5 solchen Wandlern, die sequentiell verarbeitet werden, lägen 5 MHz Datenfrequenz vor. Für andere Schaltungsteile, die z. B. asynchron an die Peripherie andocken, sowie reine »state machines« können Schaltungsteile auf der 2-4 fachen Frequenz betrieben werden.

Generell sind Fläche und Geschwindigkeit konkurrierende Größen, zwischen denen ein Optimum gefunden werden muss. Für die preiswerten FPGA-Serien wie Spartan (Xilinx) und Cyclone (Altera) sind aufgrund technologischer Randbedingungen etwa 10-30% weniger Taktgeschwindigkeit bei gleichem Design zu erwarten als bei den großen Brüdern der Virtex- (Xilinx) bzw. Stratix-Familie (Altera). Es muss mit mehr Verbrauch an Logikelementen und Taktzyklen gerechnet werden (weniger Routingreserven, geringere Zahl von LUT-Eingängen, langsamere Logikelemente). Dafür sind sie sehr preiswert.

Funktionstechnisch identische Chips werden oft in zwei oder mehr Geschwindigkeitsklassen (speed grades) angeboten, die sich meist durch Bauteilselektion bei der Produktion ergeben. Grob kann man ca. 5%-10% höhere Taktung zwischen zwei speed grades erwarten.

== Herstellung ==

FPGAs heutiger Bauart sind hochkomplexe Strukturen, da sie einerseits sehr hochgetaktet werden müssen, umfangreiche Funktionen bewerkstelligen sollen und damit genügend Resourcen haben müssen, andererseits aber preisgünstig und flexibel sein sollen, was umfangreiche Umschaltmöglichkeiten erfordert. Damit sind FPGAs als universelles Bauteil vergleichsweise teuer. Umso problematischer ist deren Fertigung:

=== Herstellungsprozess ===
FPGAs werden als Analogschaltkreis unter Verwendung von Standardbibliotheken entwickelt, indem fertige, mehrfach simulierte und getestete Blöcke zusammengeschaltet werden. Dabei haben IO-Zellen, Schaltmatritzen und vor allem Controller, RAM-Blöcke und hardcores ihre Funktion mehrfach auf Silizium bewiesen.

=== Hersteller ===

Die größten Hersteller von FPGAs sind [http://www.altera.com Altera] und [http://www.xilinx.com Xilinx]. Weitere Hersteller sind [http://www.latticesemi.com/ Lattice], [http://www.actel.com Actel] und [http://www.atmel.com Atmel].

Einige Hersteller wie Altera verfügen über keine eigene Fabrik (-> "fabless"), sondern lassen ihre entwickelten FPGAs und ASICs bei wechselnden Halbleiterherstellern fertigen. Dies führt zu jeweils günstigen Produktionskosten, allerdings auch zu Qualitätsschwankungen. Auch Liefergarantien sind schwerer zu erhalten, besonders, wenn man darauf angewiesen ist, dass ein Chip auch in 25 Jahren noch zu bekommen ist.

== Anwendung und Programmierung ==
=== Erstellung der FPGA firmware===

==== Design Flow ====
Der Aufbau komplizierter, applikationsnaher Strukturen wird meist durch automatische Routing- und Synthesewerkzeuge erledigt, welche mit einer logischen, funktionellen Beschreibung der Architektur in einer Hardwarebeschreibungssprache wie z.B. [[VHDL]] oder [[Verilog]] "gefüttert" werden. Die Hardwarebeschreibung gelingt ihrerseits z.B. mit Code-generierenden Werkzeugen, mittels derer zuvor Logikstrukturen, hardwarenahe Strukturen, Ablaufdiagramme und Zustandsautomaten formuliert wurden.

Die Korrektheit der Funktion einzelner Blöcke wie der gesamten Schaltung wird mit Simulationswerkzeugen geprüft und im Sinne der Validierung formell nachgewiesen und dokumentiert.

==== Wiederverwendbarkeit ====
Durch die Standardisierung der Architektur einerseits und die Entkopplung von applikationsorientierter Beschreibung sowie Chip- und Hersteller-spezifischer Synthese andererseits, wird die Hardware quasi als Software gebaut. Dies wiederum schafft alle Optionen der Wiederverwendung und Austausch von "Hardwareteilen". So stehen inzwischen komplett nutzbare Schaltungen wie serielle Bausteine, RAM-Controller und vieles mehr zur Verfügung - teilweise sogar in Form von Open Source Projekten.

Andererseits ist eine Tendenz erkennbar, dass Hersteller ihre Software und die damit erstellbare VHDL, speziell bei IP-Cores, immer stärker schützen und abkapseln. Diese produzieren kaum noch allgemeine VHDL, sondern nur noch herstellerspezifische Scripte. Zudem führen immer grösser werdende Unterschiede in den Chipstrukturen und Resourcen in modernen FPGAs dazu, dass die Portierbarkeit weiter eingeschränkt wird. Dies ist besonders bezüglich der Integration von Peripherie-Controllern oder ganzer Mikrocontroller der Fall. Bei SOPC-Systemen sind die generierten Strukturen praktisch überhaupt nicht mehr von einem FPGA-Hersteller zum anderen zu portieren und oftmals nicht einmal mehr zwischen FPGA-Familien desselben Herstellers kompatibel.

=== Anbindung an Mikrocontroller ===
Es gibt unterschiedliche Arten, wie ein FPGA mit einem Controller verbunden sein kann. In der Regel ist der Controller der Master und arbeitet auf den FPGA. Dabei ist zwischen direkten impulsiven Zugriffen auf den FPGA nach Massgabe des internen Ablaufs im Prozessor, die jederzeit und wortweise an irgendeine Adresse erfolgen können und blockweisem Schreiben, also permanentem Datenfluss ohne Adressierung zu unterscheiden.

Das wortweise Schreiben und Lesen erfolgt in Form eines klassischen Speicherinterfaces durch aktiven Zugriff auf den FPGA oder den FPGA hindurch auf einen RAM-Bereich, in den der FPGA seinen Speicher einblendet.

==== Memory Mapped ====
Hierunter versteht man den Zugriff des Mikrocontrollers auf das FPGA in Form eines Speichers. Dabei muss der FPGA ein klassisches Speicherinterface zur Verfügung stellen. In einzelnen Fällen reicht es auch, wenn dieser ein internes Blockram im dual ported Modus an die Ports des Mikrocontrollers heranführt.

==== Streaming IO ====
Liefert ein Mikrocontroller häufig grosse Datenmengen an einen FPGA, ist es mitunter sinnvoll auf einen aktiven Zugriff mit Wortadressierung zu verzichten und einen pipeline-Zugriff zu implementieren. Der FPGA "hört" dazu den Datenbus des FPGA ab und erkennt anhand z.B. der Aktivierung nur einer Schreibleitung den Beginn des Sendens und empfängt dann mit jedem Takt ein Wort. Was die Daten zu bedeuten haben und wohin sie zu schreiben sind, muss dann in den Daten codiert werden. Auch ist es denkbar den FPGA so zu konfigurieren, dass beim Schreiben auf eine ganz bestimmte Adresse ein grösserer Datenblock übergeben wird.

In beiden Fällen wird im FPGA ein FiFo eingesetzt, der synchron mit dem Mikroprozessortakt beschrieben wird. Auf der Seite des FPGAs muss eine FSM überwachen, ob Daten ankommen und diese geeignet verarbeiten.

==== Indirekte Busverbindung ====
Oftmals sind FPGAs und MCUs in grösseren Systemen über Busse verschaltet. So kann der FPGA an einem klassischen Daten-Adress-Bus parallel zu einem RAM und anderen Bausteinen über Adressdekodierung und Chip-Select betrieben werden, oder er wird über ein logisches Interface wie SPI angebunden.

=== Anbindung an RAMs und ROMs ===

==== DDR2 / DDR3 - RAM ====
Während die Ansteuerung eines normalen SRAMS mittels eines klassischen memory mapped interface recht einfach ist, bedürfen DRAMS- speziell mit DDR-Funktion einer aufwändigeren Schaltung, welche die komplizierte Kommoandostruktur der DDR-Ansteuerung versteht, pipelining und gfs cashing praktiziert und das RAM entsprechend bedient. Dabei sind RAM-spezifische Randbedingungen (refresh / self refresh) zu beachten. Für FPGAs existieren hier eine Reihe von konfigurierbaren IP-Cores

==== SPI-Flash ====
Die Anbindung über SPI erfolgt meist über serielle Verbindungen wie I2C, da nur wenig Bandbreite benötigt wird. In selteneren Fällen werden FPGAs parallel mit einem Flash verbunden, z.B. bei grossen FPGAs mit umfangreichem image, welches aus einem Flash schnell geladen werden soll.

=== Anbindung an Peripherie ===
Typische Anwendungen für FPGAs sind die breitbandige (grosse Busbreite und/oder hohe Taktfrequenz) Gewinnung- und Verarbeitung von Daten, bei denen DSPs oder MCUs nicht mehr (effektiv) eingesetzt werden können. Typische Beispiele dafür sind:

==== Videotechnik ====
[[Bildsensor]]en produzieren traditionell die grössten Datenmengen je Zeiteinheit und sind ohne FPGAs praktisch nicht mit der Aussenwelt in Kontakt zu bringen. FPGAs arbeiten hier entweder auf der Kunden- oder auch der Herstellerseite, um die komplexen Datenströme anzunehmen, vorzuverarbeiten und in eine reduziertes, praktikableres Datenformat umzusetzen. Auch die Annahme eines Videoformates ist praktisch nur mit FPGAs möglich.

Die benötigten Datenschnittstellen können mit Hilfe von Transceiver-Ports / LVDS manuell realisiert werden, oder es werden Umsetzer-Chips verwendet. Beispiele:

* HDMI-Transceiver für FPGAs ohne Gigabit-Transceiver
* SERDES-Transceiver für mittelpreise FPGAs ohne SERDES / sehr hohe Frequenzen
* Camera-Link-Deserializer (für langsame FPGAs)
* LVDS-Buffer-Deserializer (für langsame FPGAs ohne LVDS buffer)
* DVI-Buffer

Für Analoge Daten benötigt man selbstredend noch Video-ADCs / Video-DACs, die überhaupt erst ein digitales Signal erzeugen.

==== Gigabit-Ethernet ====
Für die Umsetzung auf den (praktisch analogen) [[Ethernet]]-Standard braucht es immer einen sogenannten [[Glossar#p|PHY]], also einen physikalischen Zusatzchip. Dieser vollzieht die [[Glossar#p|5PAM]]-Modulation und die Codierung im 10/8-Format. Die Ankopplung an den FPGA erfolgt direkt.

Während althergebrachte 100MBit-Verbindungen dabei oft noch mit UCs und softcores zu bedienen waren, können 1GBit-Netzwerke nur noch mit FPGAs sinnvoll angesteuert werden. Umgekehrt ist das Gigabit-Netzwerk eine gute Lösung, um Daten effektiv und billig in einen PC zu transportieren, da moderne PCs alle eine GBit-Karte besitzen und die Datenrate bei schnellen CPUs auch weitgehend ausgenutzt werden kann. Typische Bandbreiten bewegen sich für Linux mit unmodifizierten Treibern bei 700MBit-800MBit.

Der [[Glossar#m|MAC]], bzw MAC-ähnliche Funktionen, sind im FPGA direkt implementierbar (z.B. mit IP-Cores) und können mit einfachen [[Glossar#f|FSM]]s angesteuert werden. Für die Verwendung von C-Software ist es notwendig, einen hardcore zu verwenden, da mit softcores die Bandbreite kaum erreicht werden kann. Besonders das Verpacken der Daten, die Abarbeitung des Protokolls sowie die Bildung der Ethernet-header mit Checksummen, CRC und zusätzlichen Prüf- und Steuerinformationen sind in VHDL sehr einfach und entspannt zu erzeugen, weil parallel gearbeitet werden kann.

Die Bandbreite einer typischen [[Glossar#g|GMII]]-Verbindung mit [[Glossar#d|DDR]] beträgt 2x150MHz x 8 Bit, was mit mittleren FPGAs gut zu machen ist. Die interne Bandbreite ohne header beträgt dann typisch etwa 800MBit, z.B. 50MHz x 16 Bit für die Daten. Ab diesem Punkt ist dann wieder ein schneller softcore einsetzbar.

==== High-Speed-USB ====
Für die Übersetzung auf den immer schnelleren USB-Bus (inzwischen bis 5Gb Bandbreite!) stehen Chips zur Verfügung, die sich in vergleichsweise einfacher Weise ansteuern lassen. Eine passende Sende- und Empfangsarchtiktur ist in FPGAs relativ rasch zu implementieren.

=== Implementierung von Steuerfunktionen ===
In den meisten FPGA-Applikationen sind mehr oder weniger komplizierte Abläufe zu integrieren, die den Datenfluss steuern und die einzelnen Komponenten so mit einenander verschalten, dass sie wunschgemäss aufeinander reagieren.

Mit nativem VHDL sind einfache sequenzielle Abläufe mit überschaubaren Verschlachtelungstiefen und Schleifen direkt in Form von Zählersteuerungen oder abstrakten State Machines realisierbar. Dazu kann auf die automatische Codegeneration aus state machine designern heraus oder die halbautomatische Erzeugung von Code mit z.B. Excel zurückgreifen, die die Enumeration von states, die Abfragen und die Sprünge zu den nächsten states automatisch vollzieht. Dies hat aber seine Grenzen, weil dies früher oder später unübersichtlich wird und nicht mehr so gut pflegbar ist. Zudem kann sich der Code stark aufblähen und die Zusammenfassung etwaiger Redundanz durch die Synthese zu hohen Synthesezeiten führen.

Applikationen, die nicht ganz so zeitkritisch sind, sollten lieber mit einer flexiblen, verschachtelten Struktur von 2 state machines abgearbeitet werden, bei denen der Ablauf von der Generation des Timings für die Hardware getrennt ist. In reinen Ablaufsteuerung stehen dann wie in einem Befehlsspeicher abstrakte Codes hintereinander und werden mittels einer intelligenten Struktur sequenziell abgearbeitet werden. Diese agiert wie ein Befehlsinterpreter und stösst eine untergeordnete state machine an. Damit wird zwar mehr Zeit für die Verwaltung benötigt, es führt aber letztlich zu quantitav weniger Steuer-Code. Die Befehlsfolgen lassen sich z.B. günstig in einem ROM realisieren. Die gesamte Steuerung wird intelligenter und insgesamt kleiner.

Eine deartige Steuerlogik lässt sich soweit ausbauen, dass untergeordnete state machines wie Unterprogramme ablaufen und durch ein flexibles Hauptprogramm gesteuert werden, womit sie sich immer mehr einer Prozessorarchitektur annähert.

Wenn die Komplexität viele "Befehle" erfordert, gfs noch gerechnet und viel entschieden werden muss, lohnt der Rückgriff auf einen vorgefertigen Softcore. Dies hat den Vorteil, dass eine Standardstruktur verwendet wird, für die es erweiterte Entwicklungs- und Debugging-Software gibt. Spätestens, wenn man mit virtuellen Datenstrukturen und rekursiven Funktionen arbeitet, oder z.B. Zeichenkettenverarbeitung braucht, ist ein Softcore unerlässlich,
weil dann alle Methoden-, Variablen und sonstige Aspekte der jeweiligen Hochsprache verwendet werden können.

=== Beispiele von VHDL Code ===
Siehe [[VHDL_Softwarepool]]

== Einsatz in elektronischen Schaltungen ==
Der Einsatz von modernen FPGAs erfordert neben dem grundsätzlichen Wissen im Bezug auf den design flow und den für FPGAs optimierten Schaltungs- und Rechenstrukturen auch grosses Knowhow im Bereich der analogen Schaltungstechnik sowie auch der effektiven Vorgehensweise beim Design.

=== FPGA aus analoger Sicht ===
FPGAs bedürfen heute eines perfekten Layouts, um mit RAMs und externen Chips zusammenarbeiten zu können, da sowohl die internen, als auch externen Taktfrequenzen rapide angestiegen sind. Ferner ist grosses Augenmerk auf die Spannungsversorgungen zu legen.

=== Integration ins PCB ===
Weiter ist es heute kaum noch möglich, FPGA-Design vom board-Design funktionell zu trennen, wie man es mit Blick auf den scheinbar rein logischen Schaltungsentwurf glauben könnte und früher auch der Fall war. Da FPGAs heute stark dedizierte Funktionen enthalten, die nicht in jeder IO-Zelle zur Verfügung stehen oder spezielle Bank-Konfigurationen erforden, muss der Schaltungsentwurf und das Layouten des FPGAs und des Boards einhergehen.

=== Entwicklungsboards und Starter-Kits ===
Von mehreren Seiten gibt es im Markt eine ganze Palette von sogenannten Entwicklungs- und Evaluierungsboards. Diese eignen sich nicht nur zum Kennenlernen des Chips, bez. zur Validierung der Lösung (ob die Schaltung wie gebaut auch im konkreten Ziel-FPGAs arbeitet) sondern werden immer öfter auch in bestehenden Systemen verbaut, weil aufgrund einer geringen Stückzahl die Selbstentwicklung nicht lohnt.

Siehe [[Liste von FPGA Eval boards]]

=== FPGA als Ersatz von alten digitalen ICs und Prozessoren ===
Es gibt vielfach den Wunsch, ICs, die nicht mehr direkt zu beschaffen sind, durch FPGAs (oder wenn möglich CPLDs) zu ersetzen. Gerade ältere Schaltungen
basieren aber durchaus noch auf 5V TTL und CMOS Logik. Oft sind die Systeme nicht ohne sehr hohen Aufwand und Verlust der Wirtschaftlichkeit zu ersetzen (wie ältere, produktive Industrieanalagen oder komplexe Rechensysteme - aber auch wenn es um die Erhaltung alter Hardware bei "retro-computing" geht).

Nun bieten heute erhältliche (und günstige) FPGAs - aufgrund ihrer verwendeten Technologie - keine direkte 5V Kompatibilität mehr. FPGAs wie die Spartan II (nicht IIe), erlauben zumindest noch "5V Toleranz" auf den I/O-Pins. Das heißt: das FPGA wird zwar mit 3.3V versorgt und kann daher nur 3.3V am Ausgang treiben, erlaubt aber 5V von externen Bausteinen am Pin - dies ist nach wie vor TTL kompatibel, aber auch viele CMOS-Schaltungen können so durchaus noch betrieben werden.

Für neueste 3.3V (oder weniger) FPGAs kann man Levelshifter-Schaltungen verwenden, die entweder bidirektional ausgeführt sind und ein "open-drain-artiges" Verhalten zeigen (also beide Seiten können die Leitung nur auf Lowpegel treiben, der Highpegel wird durch pull-up Widerstände erreicht) oder die unidirektional (mit optionaler Richtungsumkehr und/oder Treiberdeaktivierung über Kontrolleingänge) gebaut sind. Verwendung von Spannungsteilern, Zenerdioden-Schaltungen oder Ausnutzung von Diodenlimitierungen der I/O Treiber des FPGAs (und Verwendung eines Serienwiderstands zur Stromlimitierung) sind zumeist nur für niedrige Schaltfrequenzen gut geeignet und sorgen für eine erhöhte Stromaufnahme.

Siehe auch: [[Pegelwandler]]

== Debugging-Hilfen ==
=== Soft-Debugging ===

=== Logikanalysatoren ===
Gerade beim [[Debugging]] größerer FPGA-Designs ist es oft notwendig, auf interne Signale und Busse zuzugreifen, die aus routing- oder Platzgründen nicht an Pins des FPGAs gelegt - und mit konventionellen Analysatoren beobachtet werden können. Nebst den einschlägigen Tools der Hersteller, welche Signal probing über JTAG gestatten (z. B. ChipsScope und SignalTap), werden in FPGAs oft mehr oder weniger komplexe [[Logic Analyzer]] integriert, welche die internen Signale in vielfältiger Weise aufzeichnen. Diese werden in Block-RAMs oder FIFOs gespeichert und durch externe Master ausgelesen. Hier kommen auf der Platine befindliche MCUs oder fremd zugreifende FPGAs / CPUs in Betracht, welche über unterschiedliche Kommunikationsverbindungen (seriell, parallel, LVDS) angeschlossen sind. Dazu werden in die FPGAs entsprechende Cores und state machines instanziiert und mit Software auf PC-Seite ausgelesen.

Nachfolgend einige Beispiele:

==== Automatisch instanziierte Logic Analyzer ====
Praktisch alle FPGA-Hersteller bieten die Möglichkeit, mit einem internen Tool ein script zu erzeugen, welches der Synthese übergeben wird, welche dann anhand von Signallisten und diversen Randbedingungen einen LA automatisiert aufbaut und verdrahtet. SampleZeit und -Takt sind dabei genauso einstellbar, wie RAM-Tiefe und -Breite. Die so generierten Datenpakete können dann mittels JTAG ausgelesen werden. Im Continous-Betrieb können so sogar permanente Datenausgaben wie bei einem Oszilloskop vorgenommen werden.

==== Proprietärer serieller Logic Analyzer ====

Die einfachste Möglichkeit ist die direkte Instanziierung eines Blockrams als FIFO mit "breitem" Busanschluss: Linksseitig besitzt das FIFO eine Breite von z. B. 256 Bit (Xilinx-Rams lassen sich ohne weitere Umbeschaltung über den Wizzard mit bis zu 1024 Bits deklarieren und nutzen). Rechtsseitig einen 16- oder 32 Bit breiten Busanschluss für einen Prozessor bzw Parallelinterface oder einen 1 Bit breiten Anschluss für ein serielles streaming interface. Mit einem FiFo-enable können die zu sampelnden Zeiten (Busphasen) festgelegt werden, z. B. anhand eines Kriteriums wie die Erfüllung einer bestimmten mathematischen Bedingung, die man in VHDL formuliert, oder es wird einfach ein Trigger gesetzt. Solange das FiFo nicht voll ist, kann geschrieben werden, was durch die interne FiFo-Verwaltung selbst bereits komplett geregelt wird.

Beim einfachen seriellen Logic Analyzer benötigt man nur noch einen kleinen Core, der permanent das FiFo liest, und den seriellen Overhead (Startbit, Stoppbit, Parity und gfs CRC) hinzufügt. Mit einem einfach Pegelwandler kann so ein PC direkt angeschlossen werden.

Auch denkbar ist die Anbindung an ein fremdes FPGA-board mit viel Speicher über (LV-)DS-Kommunikation. In komplexeren Systemen wird ein CAN- oder USB-Core eingesetzt.

Wenn mittels des Kriteriums nur ganz bestimmte kritische Phasen herausgesampelt werden (z. B. das Auftauchen eines bestimmten Rechenfehlers im FPGA) und so das Datenaufkommen je Zeiteinheit über längere Zeit betrachtet eher gering ist, kann bei geeignetem Datendurchsatz in Echtzeit dauerhaft mitprotokolliert werden.

==== BusProbe ====
Mit der BusProbe, dem Debugging Core von abaxor engineering, kann der Entwickler den Signalfluss im FPGA-Design auch über einen längeren Zeitraum überwachen und am PC aufzeichnen. Der Core verarbeitet an jedem Eingang einen kompletten Bus.

Die Daten werden gemultiplext zum PC geschickt und dort per Software demultiplext. Im PC erfolgt auch die Auswertung mit beliebigen Analyse-Tools.

Gegenüber dem Betriebssystem verhält sich die BusProbe wie eine Festplatte, von der die Daten mit gewöhnlichen Zugriffen gelesen werden können.

* Streaming der Daten zum PC mit mehr als 20 MByte/s
* keine Treiber im PC da Nutzung von Standardschnittstellen (USB oder IDE)
* Hot-Plugging
* Visualisierung mit beliebigen Programmen
* geringer Logikaufwand

[http://www.abaxor.de/produkte.html abaxor.de-Webseite]

==== open source Logikanalysator ====
===== sump.org =====
Ein einfacher, übersichtlicher Logikanalysator findet sich auf sump.org. Er liegt im Quelltext vor wird mit ins Design einsynthetisiert. Als Speicher dient wahlweise SRAM oder internes RAM. Es können 32 Kanäle mit 100 MHz (oder weniger) gesampelt werden. Die Bediensoftware läuft platformunabhängig unter Java und benötigt eine serielle Schnittstelle (auch über USB-seriell Wandler) zum Core.

[http://de.sump.org/projects/analyzer/ sump.org-Webseite]

===== Weitere =====

http://www.mikrocontroller.net/articles/Logic_Analyzer

== FPGA-Design aus Projektsicht ==
Vielfach wird die Auffassung vertreten, die FPGA-Entwicklung gehöre zur Hardwareentwicklung, da es sich um ein elektronisches Bauteil handle, welches lediglich konfiguriert werde. Man spricht bei der FPGA-Entwicklung oft auch ausdrücklich nicht vom "programmieren". Beides ist aus folgenden Gründen unrichtig:

* Die Vorgehensweise, die Funktion einer Schaltung allein durch virtuelle Konstrukte wie Logikgatter, Multiplexer und Schalter zu definieren, die in der Praxis so nicht exisiteren, sondern in Form von LUTs realisiert werden, ist bereits eine abstrahierte Handlung.

* Der erzeugte output des Designers besteht aus Grafiken, Skripten, Anweisungen, Einstellungen der Synthesesoftware und Strukturvorgaben, die nicht selbst Hardware sind, sondern Anweisungen an einer Erzeugersoftware und stellen damit ein Programm (lat. "Vorschrift") dar.

* Der erzeugte output der Erzeugersoftware wiederum ist selbst ein Programm und wird zusammen wie die Quellinformation des Designers archiviert, versioniert und wie übliche Software gehandhabt.

* Neben den allein schon durch die Nutzung bestimmter Funktionen wie RAMs, MCBs und Soft-Cores implizit vorgegebenen Abläufen im FPGA, werden fast immer auch noch weitere, explizite Handlungsabläufe mit Reaktionen auf äussere Einflüsse implementiert, die als klassische Software aufzufassen sind.

Damit erfüllt die FPGA-Entwicklung formell mehrere Bedingungen, die als Softwareentwicklung aufgefasst und eingruppiert zu werden. Andererseits ergeben sich durch die weiter oben erwähnten, sehr ausgeprägten Themen im Bereich der Elektronik (z.B. der Nachrichten- und HF-Technik) sowie der Physik eine Vielzahl von harten Anforderungen, der klassischen Hardwareentwicklung.

Zusammengefasst kann man daher 2 grundlegende Aspekte des FPGA-Designs konstatieren, die je nach Anwendungsfall als mehr oder weniger unabhängig von einander gesehen werden können.

=== Logikdesign ===
Das funktionslogische Design besteht aus dem Entwurf des Systems, der benötigten Abläufe und der zu realisierenden Protokolle und Berechnungsverfahren. Hierbei sind Kenntnisse im Systementwurf, gfs. von SOPC-Systemen, der üblichen Bussysteme und der Software generell nötig. Hinzu treten Kenntnisse in der elementaren und/oder der komplexen abstrakten Mathematik und der Signalverarbeitung sowie der theoretischen Nachrichtentechnik. Ferner sind Methoden des Script- und Softwareentwurfes, sowie Handhabung von Software nötig.

Dies alles stellt den Anteil dar, der klassischerweise als Softwareentwicklung aufgefasst wird. Es ist die Schnittstelle zur Funktionsschicht, also der grundsätzlichen Funktion eines Gerätes.

=== Schaltungsdesign ===
Das praktische, hardwaretechnische Anteil des Designens erstreckt sich zudem über die physikalischen Themen der Temperatur- und Betriebsstabilität, der Strahlungs- und Störsicherheit, der Produzier- und Herstellbarkeit, des Wirkens und der Fehleranfälligkeit interner Schaltungsstrukturen, der Art und Weise der Ressourcennutzung bei unterschiedlichen Realisationsformen - besonders, wenn es auch Kostenoptimierung ankommt, des Analogverhalten der IOs und internen Strukturen im Bezug auf Frequenz und Pegel, der Signalintegrität der FPGAs und der Leiterbahnen sowie alle Anfordernisse im Umfeld der anzubindenen Chips.

Dies ist der Anteil der gerne als Hardwareentwicklung eingestuft wird. Er stellt die Schnittstelle zur Physik und der Fertigung dar.

=== Fazit ===
Die Verwendung von FPGAs ist heute komplexer denn je und erfordert in aller Regel starke Kenntnisse in beiden Feldern. FPGA-Entwicklung kann praktisch wie die Einbindung eines komplexen Evaluierungsboards oder einer programierbaren Steuerplatine mit festgelegten Funktionen aufgefasst werden.

== Siehe auch ==
* [[Hardwarebeschreibungssprachen]]
* [[Reset für FPGA/CPLD]]
* [[Taktung FPGA/CPLD]]
* Projekt [[Audio-DSP mit Spartan 3-FPGA]]
* Projekt [[FPGA Lab]]

== Forumlinks ==
* [http://www.mikrocontroller.net/topic/274159 Tonleiter im PLD] - Beispiel einer einfachen Musikapplikation
* [http://www.mikrocontroller.net/topic/326462?goto=3564346#3564346 Kopierschutz] für FPGAs und programmierbare ICs

== Weblinks ==
* [http://www.fpga4fun.com/index.html FPGA4Fun] - FPGA-Projekte, größtenteils mit Altera und Verilog
* [http://marcowuen.wordpress.com/2014/09/08/overview-cheap-fpga-development-boards/ Übersicht Development Boards] - Zusammenstellung günstiger FPGA Boards unter 100$
* [http://video.google.com/videoplay?docid=-4969729965240981475 Ein Vortrag, auf Englisch: General Purpose, Low Power Supercomputing Using Reconfiguration Logic]
* http://www.opencores.org - FPGA-Projekte, Opensource, jeder kann seine Eigenen einstellen und an anderen mitarbeiten. U.a. gibt es verschiedene CPUs für FPGAs.
* [http://pin4.at/pro_misc.php#fdil Projekt "FDIL v2"]: 5V DIL-Ersatz mit 100kGates Spartan II FPGA (Englisch)
* [http://members.optushome.com.au/jekent/FPGA.htm John's FPGA Page]
* [http://www.embedded.com/columns/whatsnew/197003073 More about designing with embedded FPGAs] by Bernard Cole, Embedded.com
* [http://chaosradio.ccc.de/cre117.html Chaosradio Express - FPGA]
* [http://www.pin4.at/pro_custom.php Custom IC replacements] - DIL / TTL-Replacements mit FPGA (Englisch)

[[Category:FPGA und Co|Grundlagen|Bauteile]]

AVR PWM

2015-09-25T09:55:09Z

153.96.195.35: /* Pseudocode */ T=100s => f=1/100 Hz

==Vorwort==

Dieser Artikel ist noch nicht vollständig!
Und außerdem überschneidet er sich teilweise mit dem Tutorial, weil PWM und Timer zum Verständnis praktisch dasselbe sind.
Vielleicht kann ja jemand, der gerade dabei ist, sich diese Dinge anzueignen, die Beschreibung vorantreiben (erweitern/entschlacken)?

Hier sollen die Möglichkeiten und die Funktionsweise der PWM mit AVRs erläutert werden, so daß Anfänger auf ihrem Weg zum Ziel unterstützt werden, ohne sich erst durch die wenig erklärenden Beiträge im Forum zu quälen.
Auch wenn das Verständnis (hoffentlich) dann nicht mehr aus dem Datenblatt kommen muß, ist dieses für die spezifischen Einstellungen und Feinheiten absolut notwendig. Aber mit dieser Übersicht sollte es leichter fallen, die relevanten Informationen schneller zu finden.

Ich gehe dabei von meiner Situation aus: "Gerade mit AVRs angefangen, die LED blinkt, Taster wird abgefragt, schonmal von PWM gehört und unter den AVR Pins welche mit OC.. entdeckt, das hängt damit irgendwie zusammen."
Man sollte sich auch um die Prozessorfrequenz gekümmert haben, also die [[AVR_Fuses]] entsprechend gesetzt haben.

Wer in Begriff steht, sein erstes Board zu ätzen, sollte sich über die verschiedenen Möglichkeiten, die die OCnx Pins bieten, informiert haben.

Übrigens lässt es sich besser lesen, wenn man sein Browserfenster so schmal macht, daß der Text in eine schöne Spalte gezwungen wird.

==Einführung==

Im AVR-GCC-Tutorial werden im Abschnitt [[AVR-GCC-Tutorial#DAC (Digital Analog Converter)|DAC-Optionen]] verschiedene Möglichkeiten angesprochen, analoge Spannungen zu generieren.

Darunter fällt auch die [[Pulsweitenmodulation]], bei der durch schnelles Ein- und Ausschalten eines Ausgangs (über einen Filter) eine [[analog]]e Spannung generiert werden kann.

Beim Dimmen von Lichtquellen wirkt die Trägheit des Auges als Filter, wenn z. B. eine LED im Mittel die Hälfte der Zeit eingeschaltet ist, scheint es also, als würde sie nur halb so hell leuchten.

Bei Motoren läßt sich PWM gut zum Dosieren des Stroms einsetzen, ohne große Verluste zu haben. Für einen Teil der Zeit wird also der volle Motorstrom eingeschaltet, d.h. das Drehmoment ist maximal.

Die Rechtecksignale lassen sich mit Mikrocontrollern auf zwei Wegen erzeugen:

PWM per Software
* Kostet Rechenzeit, erhöhter Softwareaufwand
* Signalausgabe auf jedem I/O-Pin möglich
* Höhere Kanalanzahl möglich

oder

PWM per Hardware
* Läuft unabhängig vom Programm
* Bietet mehr Möglichkeiten bei gleichem Softwareaufwand
* Signalausgabe nur auf bestimmten, fest vorgegebenen Pins möglich
* Benötigt einen Timer
* Nur begrenzte Anzahl an PWM-Kanälen vorhanden (viele verbreitete AVR-Typen haben 2 bis 3, neuere auch mehr)

Alles was mit Pulsen und Modulation zu tun hat, hat auch was mit Zeit zu tun – denn im Prinzip soll mit einer bestimmten Frequenz für eine bestimmte Dauer ein Pin eingeschaltet werden.

Alles was bei Mikrocontrollern mit Zeit zu tun hat, hat wahrscheinlich auch etwas mit einem [[Timer]] bzw. Counter zu tun.

==Timer / Counter==

Unter [[Timer]] bzw. [[Counter]] (T/C) steht noch nicht soviel, aber man sollte kurz mal reinsehen, oder mehr dazu schreiben, oder die fehlende Verknüpfung anlegen.

Ein Timer ist nichts anderes als ein selbständiger Zähler (Counter), der mit einer bestimmten Frequenz einen Wert raufzählt. Und zwar in Hardware, also unabhängig vom Programm. Seine Zählfrequenz wird vom Prozessortakt abgeleitet, das erledigt der [[Prescaler]] in einstellbaren Schritten (Frequenzteiler).

Der Zählerstand läßt sich sowohl in Software als auch von der Hardware selbst überwachen - und schon lassen sich damit periodisch Ereignisse auslösen.

Deswegen lassen sich die T/C für viele Zwecke verwenden, wir wollen den T/C für PWM nutzen (trotzdem gleich eine Übersicht über die verschiedenen Modi).

Es lohnt sich natürlich, das Prinzip der T/C verstanden zu haben. Ein Blick ins GCC-Tutorial lohnt, die Atmel Application Note 130: Setup and Use the AVR Timers schadet auch nicht.

Wie schon angedeutet, gibt es - je nach AVR - einen oder mehrere T/C . Sie unterscheiden sich erwartungsgemäß durch ihre Parameter und Optionen, z. B. die Auflösung, Frequenz, Zählweise und andere Betriebsmodi.

Und natürlich auch durch den Namen, der sich auch in den [[Register]]n widerspiegelt: Sie werden nämlich numeriert (im Folgenden hier und im Datenblatt mit Platzhalter n).

T/C 0 ist beim tiny2313 der 'einfache' mit 8 Bit Auflösung (das Aus-An Verhältnis läßt sich in 256 Stufen einstellen), T/C 1 dagegen hat eine Auflösung von 16 Bit und bietet einige weitere Möglichkeiten.

=== 8 oder 16 Bit ? ===
Außer der Tatsache, daß die Auflösung bei 16 Bit mit 65536 Stufen um einiges feiner ist, gibt es noch folgende Unterschiede:

* Er verwendet einige 16 Bit Register
** Schreiben/Lesen dieser Register erfolgt in Schritten
*

Mit dem Zähler alleine kann man noch nicht so viel anfangen. Ausgedacht wurde deswegen außerdem die

=== Output Compare Unit ===

was soviel bedeutet wie Ausgangsvergleichseinheit.

Jeder Zähler hat eine oder mehrere voneinander unabhängige Output Compare Units (OC), auch wieder mit den dazugehörigen Registern.

Die verschiedenen OCs und ihre Register werden mit Buchstaben ('A', 'B') benannt. (Im PWM Modus hängt das direkt mit den Pins zusammen: OC1B ist der Ausgang der OC des T/C 1. Dazu gleich mehr..)

Die OC vergleicht den Zählerstand (im Register TCNTn) ständig mit ihren eigenen Registerinhalten (OCRnx). Wenn diese übereinstimmen, passiert etwas.

Was passiert, wird bestimmt durch die

=== Betriebsmodi ===

Der Zähler zählt. Die OC Unit vergleicht dessen Zählerstand mit einem Wert. Wenn diese übereinstimmen, kann etwas passieren.

Weil es hier gleich mit den Einstellungen in den Registern losgeht, noch ein Hinweis:

Die Kontrolle über das Verhalten der Zähler und OCs wird über Register vorgenommen, deren Namen nichts mit den OC Units zu tun haben!
Die Einstellungen sind lediglich auf zwei Register verteilt, die Timer/Counter Control Register - TCCRnA & TCCRnB.

Ein paar Notizen:
* In verschiedenen Modi haben auch Bits in den Registern eine andere Bedeutung!
* Meist können Interrupts ausgelöst werden.
* Es kann häufig auch der Zählerstand per Software verändert werden.
* Die Frequenz der ausgegebenen Waveform hängt ab von
** I/O Clock (CPU)
** Prescaler
** Counter Modus

Die verschiedenen Modi (vorerst die vom 8 Bit Zähler):

* Normal (evtl. für Software PWM)
* Clear Timer on Compare (CTC) (eingeschränkte PWM)
* Fast PWM
* Phase Correct PWM

Dazu hier noch folgende Begriffe im Zusammenhang mit dem Zähler:

BOTTOM: 0x00
MAX : 0xFF bei 8 Bit, 0xFFFF bei 16 Bit
TOP : MAX oder OCRnx

==== Normal====
(evtl. für Software PWM)

Der Zähler zählt rauf (BOTTOM->MAX), und wird nicht zurückgesetzt, sondern läuft einfach über, und setzt dabei sein Overflow-Flag.
Dieser Modus wird zur PWM nicht empfohlen, weil er im Vergleich mit Hardware-PWM viel CPU-Zeit benötigt - das ist logisch:
Bei jedem Nulldurchgang müsste man einen Interrupt verwenden, der dann eine Routine ausführt, die den Ausgang umschaltet. Und man müsste den Zählerstand manipulieren, um die Pulslänge zu verändern.

Für die verhältnismäßig langsame (Menschenzeit) Programmsteuerung ist dieser Modus aber ideal. Während das Hauptprogramm i.A. einfach endlos durchläuft, wird die Programmzeit durch einen Timer(-Interrupt) in Time-Slots gerastert (z. B. 1/10s). Damit lassen sich bequem Wartezeiten bzw. zeitabhängige Ereignisse steuern, ohne das Programm anzuhalten.

==== Clear Timer on Compare (CTC)====
(eingeschränkte PWM)

Der Zähler zählt hoch, bis er mit OCRnx übereinstimmt (BOTTOM->OCRnx: Match!) und wird dann auf Null gesetzt. Der maximale Wert lässt sich also über das Register OCRnx komfortabel bestimmen.

Konkret bedeutet das, dass die in diesem Modus vom Prescaler erzeugte Basisfrequenz nochmals durch den Wert von OCRnx geteilt wird.

Für PWM:

Wenn eingestellt ist, dass der OC-Ausgang bei jedem Match umschaltet (toggle), entspricht der eingestellte Wert dem Pulsweitenverhältnis.
Bei OCRnx=128 des 8 Bit T/C wäre also etwa die Hälfte der Zeit der Pin eingeschaltet.

Allerdings kann das beim T/C 0 des tiny2313 nur der Ausgang A (OC0A). Also ins Datenblatt gucken!

==== Fast PWM====

Einer von den zwei eigentlichen PWM-Betriebsarten ist der Fast PWM Modus.
Der Counter zählt von BOTTOM bis TOP, wobei TOP entweder 0xFF oder OCRnx sein kann.

Bei einem Match wird im

a) nicht-invertierenden Modus
der Zähler gelöscht, und bei BOTTOM gesetzt

b) invertierenden Modus
der Zähler gesetzt, und bei BOTTOM gelöscht.

Klingt theoretisch kompliziert, praktisch invertiert es nur den Ausgang.
Aber der Vergleichswert muss anscheinend ständig aktualisiert werden!?

Dieser Modus hat eine asymmetrische Ausgangsform, weil der Ausgang periodisch umgeschaltet wird (also immer nach der gleichen Zeit) und dann nach Ablauf der variablen Pulslänge wieder invertiert wird.

Und es gibt noch einen Toggle-Modus, der allerdings nur für den Ausgang OC0A zur Verfügung steht.

==== Phase Correct PWM====

Ist nur halb so schnell wie Fast PWM, dafür aber mit symmetrischer Wellenform.

Erreicht wird das, indem von BOTTOM->TOP gezählt wird, und dann wieder runter: TOP-BOTTOM.

TOP kann entweder 0xFF oder OCRnx sein.

Auch hier gibt es wieder den nicht-invertierenden, den invertierenden, und den toggle-Modus (nicht an OC0B).

Der symmetrische PWM-Modus wird gerne für Motorsteuerungen verwendet, wenn man den Strom in den Motorwindungen messen möchte. Da man nicht während der Schaltzeitpunkte der H-Brückentransistoren messen möchte (noise), braucht man einen Messzeitpunkt der maximal weit von diesen Schaltzeitpunkten entfernt ist. Die BOTTOM und TOP Werte des Counters bieten genau dies, da sie in der Mitte des High- bzw. Lowpegels liegen.

==Praktisches Vorgehen==

* Pins low setzen
* Pins als Ausgang konfigurieren.
* Geeignete Wellenform ermitteln
* Registerinformationen für ausgewählten T/C im Datenblatt aufschlagen
* Modus & Prescaler setzen und damit starten
** Bits in Control-Register TCCRnA & TCCRnB schreiben. Siehe [[Bitmanipulation]]
* Vergleichswert OCRnx setzen

==Programmbeispiele==

===PWM per Software===
====Pseudocode====
<pre>
//Initialisierung
pwm_phase = 0 // von 0 bis 100(99) ergibt ein moduliertes Signal
pwm_soll = 30 // Tastverhältnis in Prozent (Werte von 0..100)

//alle s Sekunden tue:
wenn pwm_soll = pwm_phase dann
ausgang = LOW
wenn pwm_phase++ = 100 dann
pwm_phase = 0
ausgang = HIGH
</pre>
Das Tastverhältnis ist <math>t_\text{HIGH}=\frac{100}{\text{pwm}\_\text{soll}}</math>

Die Frequenz ist <math>f=\frac{s}{100} \text{Hz}</math>

====ASM====
Der Code ist nicht von mir, ich hab den John Honniball auch nicht um Erlaubnis gefragt, den Code hier zu posten. Trotzdem finde ich das Ganze recht nützlich und hab' es mir trozdem erlaubt:
<syntaxhighlight lang="avrasm">
; ledpwm.asm --- drive a blue LED with PWM 21/04/2006
; Copyright (c) 2006 John Honniball

.include "m8def.inc"

.org 0x0000

; Blue LED on Port B bit 2
.equ LEDPORT = PortB
.equ LEDBIT = 0

; This program drives a single LED connected to the AVR's I/O port. It
; is connected so that the cathode of the LED is wired to the AVR pin,
; and the anode of the LED is wired to the 5V power supply via a
; resistor. The value of that resistor depends on the colour of the LED,
; but is usually a few hundred ohms.

; We control the brightness of the LED with Pulse Width Modulation (PWM),
; for two reasons. Firstly, we have no analog outputs on the AVR chip,
; only digital ones. Secondly, a LED's brightness does not respond
; linearly to variations in supply voltage, but it responds much better
; to PWM.

; Pulsating LED looks better if it never quite goes "off", but cycles from
; full brightness to a dim state, and back again
.equ MINBRIGHT = 25
.equ MAXBRIGHT = 255

; This value controls how fast the LED cycles from bright to dim. It is
; the number of PWM cycles that we generate for each step in the brightness
; ramp, up and down. Larger numbers will make the pulsation slower.
.equ NCYCLES = 1

; Start of program execution after a Reset
ldi r16,low(RAMEND) ; Initialise stack to top of RAM
out SPL,r16
ldi r16,high(RAMEND)
out SPH,r16

; Initialise the hardware
ldi r16,0xff ; Set Port B to all outputs
out DDRB,r16

sbi LEDPORT,LEDBIT ; Switch off blue LED by setting output pin high

; Start with LED at its lowest level, then ramp up to maximum
dopwm: ldi r17,MINBRIGHT ; R17 holds current brightness level
l1: ldi r18,NCYCLES ; R18 counts PWM cycles, and hence pulsation speed
l2: cbi LEDPORT,LEDBIT ; Output pin low, LED on
mov r16,r17 ; R16 controls length of delay (= R17)
rcall delayn4us ; Call delay subroutine
sbi LEDPORT,LEDBIT ; Output pin high, LED off
ldi r16,255
sub r16,r17 ; R16 controls length of delay (= 255 - R17)
rcall delayn4us ; Call delay subroutine
dec r18 ; Decrement PWM cycle counter
brne l2
inc r17 ; Increase brightness by one step
brne l1

; Now ramp back down to the minimum brightness
ldi r17,MAXBRIGHT ; R17 holds current brightness level
l3: ldi r18,NCYCLES ; R18 counts PWM cycles, and hence pulsation speed
l4: cbi LEDPORT,LEDBIT ; Output pin low, LED on
mov r16,r17 ; R16 controls length of delay (= R17)
rcall delayn4us ; Call delay subroutine
sbi LEDPORT,LEDBIT ; Output pin high, LED off
ldi r16,255
sub r16,r17 ; R16 controls length of delay (= 255 - R17)
rcall delayn4us ; Call delay subroutine
dec r18 ; Decrement PWM cycle counter
brne l4
dec r17 ; Decrease brightness by one step
cpi r17,MINBRIGHT ; Have we reached the minimum?
brne l3

rjmp dopwm ; Loop back to start

; DELAYN4US
; Delay for (R16 * 4) microseconds
delayn4us: tst r16 ; R16 = 0? (no delay)
breq dly4
dly2: ldi r24,low(16)
ldi r25,high(16)
dly3: sbiw r24,1 ; 2 cycles
brne dly3 ; 2 cycles
dec r16
brne dly2
dly4: ret ; Return to caller
</syntaxhighlight>

====C====

Dies ist ein einfaches Beispiel einer dimmbaren LED als Software PWM in C.

<syntaxhighlight lang="c">
// F_CPU 4 MHz
#include <avr/io.h>

int main( void )
{
uint8_t pwm_soll = 30; // gewünschter Dimmerwert 0..100
uint8_t pwm_phase = 0; // Laufwert der Schleife 0..100

// LED + Widerstand mit PB0 und +5V verbunden
// PB0 o-----|<-----###------o Vcc 5V
DDRB |= (1<<PB0); // Pin PB0 an Port B als Ausgang
// LED ist bereits an

while( 1 )
{
if( pwm_soll == pwm_phase )
{
PORTB |= (1<<PB0); // active low LED aus
}
pwm_phase++;
if( pwm_phase == 100 )
{
pwm_phase = 0;
PORTB &= ~(1<<PB0); // active low LED an
}
}
return 0;
}
</syntaxhighlight>

Eine komplexere Variante mit Interrupts wird im Artikel [[Soft-PWM]] beschrieben.

====BASCOM====
Der entsprechende Quelltext in Bascom:

<pre>
$regfile = "m8def.dat"
$crystal = 4000000

Ddrb = &H01

Dim Pwm_phase As Integer , Pwm_soll As Integer

Do
If Pwm_soll = Pwm_phase Then
Portb.0 = 1
End If
Incr Pwm_phase
If Pwm_phase = 100 Then
Pwm_phase = 0
Portb.0 = 0
End If
Loop
End
</pre>

===PWM per Hardware===
Programmbeispiele

====ASM====
Für AtMega8.
<syntaxhighlight lang="avrasm">
.include "m8def.inc"

.def temp = r16

start:
ldi temp, LOW (RAMEND)
out SPL, temp
ldi temp, HIGH (RAMEND)
out SPH, temp

ldi temp, 0xFF
out DDRB, temp ;define PortB as output

ldi temp, 0xF3
out TCCR1A, temp ;10bit Phase Correct PWM

ldi temp, 0x0A
out TCCR1B, temp ;set Prescaler

sei

main:
ldi temp, 0x1
out OCR1AH, temp ;set pwm pin 1 highbyte

ldi temp, 0x00
out OCR1AL, temp ;set pwm pin 1 lowbyte
;pin: PortB1

ldi temp, 0x00
out OCR1BH, temp ;set pwm pin 2 highbyte

ldi temp, 0x00
out OCR1BL, temp ;set pwm pin 2 lowbyte
;pin: PortB2

loop:
rjmp loop
</syntaxhighlight>

====C====
Hier wird mit dem 16-Bit-Counter 1 im PWM ''phase correct'' 8-Bit Modus eine LED am Pin OC1A gedimmt. Die Frequenz beträgt
:<math>f = \frac{\text{Taktfrequenz}}{2 \cdot \text{Prescaler} \cdot 256} \,\text{Hz}</math>

In [http://www.mikrocontroller.net/topic/204969] wurde beobachtet, dass der Ausgabepin OC1A unbedingt vor der Initialisierung der PWM auf Ausgang gesetzt werden muss, wie auch oben unter ''Praktisches Vorgehen'' erläutert ist.

<syntaxhighlight lang="c">
DDRB |= (1<<OC1A); // Port OC1A mit angeschlossener LED als Ausgang
TCCR1A = (1<<WGM10) | (1<<COM1A1); // PWM, phase correct, 8 bit.
TCCR1B = (1<<CS11) | (1<<CS10); // Prescaler 64 = Enable counter
OCR1A = 128-1; // Duty cycle 50% (Anm. ob 128 oder 127 bitte prüfen)
</syntaxhighlight>

Ein sehr gut erklärtes C PWM Beispielprogramm (inc. vielen Codekommentaren) kann man bei [http://extremeelectronics.co.in/avr-tutorials/pwm-signal-generation-by-using-avr-timers-part-ii/ extremeelectronics.co.in] finden.

== Tiefpassfilter-Berechnung ==
Die PWM-Frequenz muß meistens mit einem Tiefpassfilter entfernt werden, da sie nachfolgende Verstärkerstufen übersteuert oder den Hörgenuss trübt. Ein einfacher RC-Tiefpass kann für Motorsteuerungen ausreichen, für Audioanwendungen ist der Abstand zwischen höchster Niederfrequenz und PWM-Frequenz zu klein. Ein aktives Filter mit Operationsverstärker kann die Lösung sein, oder ein passiver LC-Tiefpass. Dessen Berechnung mittels [http://www.aade.com AADE Filter Designer] soll hier an einem Fallbeispiel erläutert werden.

Ein ATmega48 mit 20 MHz Quarz soll mittels 10 Bit "fast PWM" des 16 Bit- Timers 1 ein Stereosignal am Pin OC1A und OC1B ausgeben. Die PWM-Frequenz beträgt somit knapp 20 kHz, nach dem Abtasttheorem sind maximal 10 kHz Nutzsignal möglich. Mit der Faustregel "6dB pro Bit" erreichen wir einen Dynamikumfang oder Störabstand von 60 dB. Etwa dieselbe Unterdrückung sollte auch das Tiefpassfilter erreichen.

[[Image:Cauerfilter.png|thumb|right|400px|Cauer-Tiefpass mit 3,3mH und 10 mH Festinduktivität]]
Zunächst brauchen wir noch eine Abschätzung der zulässigen Ausgangsbelastung. Laut Datenblatt beträgt der maximal zulässige Strom pro Pin 40 mA, entsprechend einem 125Ω Widerstand von 5V nach Masse. Mit 10 bis 20 mA entsprechend 500 bis 250Ω als Maximalwert dürfte also nichts passieren. Der zeitliche Mittelwert liegt für Audioanwendungen bei 2,5V, also der halben Maximalspannung. Ein hochohmiger Kopfhörer, z. B. 600Ω, läßt sich so noch ohne weitere Verstärker anschließen.

Die größte Filtersteilheit erreicht das Cauer- oder Elliptic Filter, auf Kosten von größeren Phasenänderungen/ Gruppenlaufzeit gegenüber anderen Filtertypen. Wir starten also das Filterberechnungsprogramm mit den Vorgaben "lowpass", "Cauer/Elliptic", "3.Ordnung", was eine Schaltung mit einer Induktivität und drei Kapazitäten berechnet. Den Ein- und Ausgangswiderstand geben wir erst mal irgendwo in dem genannten Bereich vor, die Durchlasswelligkeit kann auf 1 dB bleiben, Durchlassfrequenz wie gesagt 10000 Hz, die Sperrfrequenz etwas unterhalb der PWM-Frequenz, ca. 17500Hz, da der Dämpfungspol dann etwa auf 20 kHz fällt. Mit "analyze voltage insertion gain" berechnen wir eine Durchlasskurve und kontrollieren die korrekte Lage des Dämpfungspols. Jetzt variieren wir die beiden Widerstände, bis die Induktivität etwa einem leicht erhältlichen Normwert entspricht. Die drei Kondensatoren werden am Schluß ebenfalls mit dem nächsten Normwert bestückt. Sicherheitshalber kann man diese endgültige Schaltung noch mit einem [http://www.mikrocontroller.net/articles/Schaltungssimulation#Analog Schaltungssimulationsprogramm] überprüfen und die Bauteilwerte leicht korrigieren.

Als Induktivität kommen eher die größeren Bauformen infrage, die "Garnrollen"-Form oder die axiale Bauform 77A von Fastron. Hier gilt: je größer desto höhere Güte, wie man aus den Katalogangaben zum Gleichstromwiderstand schließen kann. Von magnetischen Wechselfeldern wie etwa Schaltregler-Trafos sollte man ein paar Zentimeter Abstand halten.

Im Bild sind zwei Schaltungen für die genannten Frequenzen mit einer 3,3mH-Drossel und einer 10mH-Drossel gezeigt. Die Kurven sind noch mit verlustlosen Bauteilen und den berechneten krummen Bauteilwerten gezeichnet. Der Widerstand am Ausgang kann auch durch die Last wie der genannte Kopfhörer gebildet werden. Ein größerer Wert hat hier wenig Einfluss auf die Filterkurve, während der Widerstand am Eingang genau den vorgegebenen Wert haben sollte.

== Siehe auch ==

* [[AVR-Tutorial: PWM]]
* Beiträge im Forum [http://www.mikrocontroller.net/forum/4 Codesammlung], die den Begriff PWM enthalten: [http://www.mikrocontroller.net/search?query=pwm&forums%5B%5D=4 hier]

[[Category:AVR]]