Entwickeln mit CPLDs (am Beispiel einer DCF-Uhr)

Transkript

1 Entwickeln mit CPLDs (am Beispiel einer DCF-Uhr) Autor: Buchgeher Stefan Letzte Bearbeitung: 15. Oktober 2006

2 Seite 2

3 Inhaltsverzeichnis 1. EINLEITUNG GRUNDLEGENDES ZU DCF SCHALTUNGSBESCHREIBUNG (DCF-UHR) SOFTWAREENTWURF MIT CPLDS AM BEISPIEL DCF-UHR Grundlagen Einteilung der Aufgabe in Blöcke Einteilung in Blöcke am Beispiel der DCF-Uhr UMSETZUNG DES DESIGNS IN AHDL...23 Schritt 1: Ein neues Projekt in Quartus anlegen...23 Schritt 2: Eingabe des Designs in AHDL...27 Schritt 3: Systemtakt definieren...38 Schritt 4: Erste Kompilierung...39 Schritt 5: Pinnummern zuweisen...42 Schritt 6: Zweite Kompilierung SIMULATION...44 Schritt 1: Ein Vector Waveform File für dieses Projekt erzeugen...44 Schritt 2: Simulator-Einstellungen...48 Schritt 3: Simulation beginnen...49 Schritt 4: Simulationsergebnis analysieren...50 Schritt 5: Zweite Simulation PROGRAMMIEREN NACHBAUANLEITUNG...55 Schritt 1: Platinen herstellen...55 Schritt 2: Platinen bestücken...55 Schritt 3: Test der Steuerplatine...58 Schritt 4: DCF-Modul montieren und erste Funktionskontrolle...58 Seite 3

4 Schritt 5: Steuer- und Anzeigeplatinen miteinander verbinden und zweite Funktionskontrolle...59 Schritt 6: Befestigungswinkel und Acrylglas-Scheibe vorbereiten...60 Schritt 7: Endmontage...61 ANHANG A: LAYOUTS...62 ANHANG B: STÜCKLISTE...64 ANHANG C: QUELLEN...66 Seite 4

5 1. Einleitung Die Abkürzung CPLD steht für Complex Programmable Logic Device und bedeutet soviel wie programmierbarer Logikbaustein für komplexe Anwendungen. Solche programmierbaren Logikbausteine werden von unterschiedlichen Herstellern angeboten und unterscheiden sich erheblich voneinander. Zudem gibt es noch unterschiedliche Technologien vom eher einfachen (PAL 1 und GAL 2 ) bis zu sehr komplexen (CPLD 3 und FPGA 4 ). Hier bei diesem Projekt wurde ein CPLD von Altera ausgewählt. Dies ist rein willkürlich, denn grundsätzlich könnte auch ein Baustein eines anderen Herstellers verwendet werden. Einschränkungen ergeben sich nur in der Anzahl der verfügbaren Pins und der Größe des Bausteins. Mit Größe ist hier nicht die Abmessung gemeint sondern die Größe der Schaltung sprich die Anzahl der Makrozellen. Bei programmierbaren Logikbausteinen ist weiters zu beachten dass die Funktion der Schaltung in den Baustein programmiert werden muss. Dazu muss diese aber zuerst in irgendeine Form erstellt werden. Hier hat sich eine spezielle Sprache entwickelt und durchgesetzt. Mit dieser Sprache ist es möglich die zu programmierende Schaltung zu beschreiben. Man nennt diese HDL 5, wobei sich hier verschiedene Dialekte entwickelt haben (VHDL 6, AHDL 7, ABEL-HDL usw.). Hier, bei diesem Projekt wurde die vom Hersteller entwickelte Sprache AHDL verwendet. Schließlich muss die erstellte Software noch in den Logikbaustein (IC) gebracht werden. Dazu gibt es vom Hersteller mehrere Downloadkabel, die entweder die parallele Schnittstelle oder die USB-Schnittstelle verwenden. Zuletzt soll noch erwähnt werden, dass der Hersteller zu seinen programmierbaren Logikbausteinen auch eine kostenlose Entwicklungsumgebung bereitstellt. Diese kann von der Hersteller-Hompage ( kostenlos gedownloadet werden. 1 PAL steht für Programmable Array Logic 2 GAL steht für Generic Array Logic 3 CPLD steht für Complex Programmable Logic Device 4 FPGA steht für Field Programmable Gate Array 5 HDL steht für Hardware Description Language 6 VHDL steht für Very high speed integrated circuit Hardware Description Language 7 AHDL steht für Altera Hardware Description Language Seite 5

6 2. Grundlegendes zu DCF Der Zeitzeichensender DCF77 befindet sich in Mainflingen, ca. 25 km südöstlich von Frankfurt am Main. Dieser Langwellensender hat, bedingt durch die niedrige Trägerfrequenz von 77,5 khz eine Reichweite von ca km bis 2000 km. (Bild 2.1) Bild 2.1: Rechweite des DCF77-Senders (Quelle: Bild 2.2: Amplitudenmodulation des 77,5kHz-Trägers Der Dauerträger des DCF-Senders senkt im Sekundentakt für 100ms oder 200ms die Amplitude der Trägerfrequenz auf 25 % ab, was einer einfachen Amplitudenmodulation entspricht. Die Länge dieser so genannten Sekundenmarken überträgt in codierter Form das Zeittelegramm. Eine Absenkdauer des Trägers um 100ms (Toleranz: ±20ms) entspricht dabei einem logischen Low-Pegel, während ein logischer High-Pegel mit einer Absenkdauer von 200ms (Toleranz ±40ms) codiert ist. In jeder 59. Sekunde wird die Absenkung nicht vorgenommen, so dass damit eine eindeutige Zuordnung des Minutenanfangs möglich ist. Die neue Sekunde beginnt, mit Ausnahme der 59. Sekunde, jeweils mit dem Absenken des 77,5 khz-trägers. Im jeweils einminütigem Zeittelegramm ist die Zeit (Stunde und Minute) der nächstfolgenden Minute sowie das komplette Datum und der jeweilige Wochentag codiert. Die folgende Tabelle zeigt die Bedeutung der 59 Bits, die pro Minute versandt werden. Bit Bedeutung Wertigkeit Bit Bedeutung Wertigkeit 0 Minutenbeginn Low 20 Telegrammbeginn High 1 Reserve 21 Minuten Einer 1 2 Reserve 22 Minuten Einer 2 3 Reserve 23 Minuten Einer 4 4 Reserve 24 Minuten Einer 8 5 Reserve 25 Minuten Zehner 10 6 Reserve 26 Minuten Zehner 20 7 Reserve 27 Minuten Zehner 40 8 Reserve 28 Prüfbit 1 9 Reserve 29 Stunden Einer 1 10 Reserve 30 Stunden Einer 2 11 Reserve 31 Stunden Einer 4 12 Reserve 32 Stunden Einer 8 13 Reserve 33 Stunden Zehner Reserve 34 Stunden Zehner Reserveantenne 35 Prüfbit 2 16 Zeitumstellung Ankündigung 36 Kalendertag Einer 1 17 Zeitzonenbit 1 37 Kalendertag Einer 2 18 Zeitzonenbit 2 38 Kalendertag Einer 4 19 Schaltsekunde Ankündigung 39 Kalendertag Einer 8 Tabelle 2.1: Zeittelegramm Seite 6

7 Bit Bedeutung Wertigkeit Bit Bedeutung Wertigkeit 40 Kalendertag Zehner Jahr Einer 1 41 Kalendertag Zehner Jahr Einer 2 42 Wochentag 1 52 Jahr Einer 4 43 Wochentag 2 53 Jahr Einer 8 44 Wochentag 4 54 Jahr Zehner Monat Einer 1 55 Jahr Zehner Monat Einer 2 56 Jahr Zehner Monat Einer 4 57 Jahr Zehner Monat Einer 8 58 Prüfbit 3 49 Monat Zehner Keine Austastung Tabelle 2.1: Zeittelegramm (Fortsetzung) Die Synchronisation des Sekundenzählers erfolgt mit Ausbleiben der Absenkung der 59. Sekunde. Die nächste Absenkung ist immer Low. Die Bits 1 bis 14 sind nicht belegt. Bit 15 zeigt durch einen High-Pegel an, dass zurzeit die Reserveantenne des DCF77- Senders aktiv ist. Im Normalfall ist dieses Bit auf Low gesetzt. Bit 16 wird eine Stunde bevor die Zeitumstellung von Sommer- auf Winterzeit bzw. umgekehrt erfolgt auf high gesetzt und mit der Zeitumstellung wieder zurückgesetzt. Die Zeitangaben beziehen sich auf die UTC-Zeit (Universal Time Coordinated). Bezogen auf die UTC-Zeit eilt die mitteleuropäische Zeit (MEZ) um eine Stunde vor, während die mitteleuropäische Sommerzeit (MESZ) um 2 Stunden voreilt. Diese Differenz wird in den Zeitzonenbits 17 und 18 ausgedrückt. Während der MEZ ist Bit 17 High und Bit 18 Low, während bei der Sommerzeit (MESZ) der Abstand zur UTC 2 Stunden beträgt und somit Bit 17 Low und Bit 18 High ist. Bit 19 kündigt eine bevorstehende Schaltsekunde an. Das eigentliche Zeit- und Datumstelegramm ist in den Bits 20 bis 58 codiert. Für die Einerstellen der Zeit und Datumsinformationen sind jeweils 4 Bit, während für die Zehnerstellen nur 2 oder 3 Bit erforderlich sind. Die Zahlendarstellung der Zeit- und Datumsinformation erfolgt im Binärformat (BCD-Code). Für die Jahreszahl werden nur die Einer- und Zehnerstelle übertragen. Die Bits 42 bis 44 geben in binärer Schreibweise den Wochentag an (der Wert 1 steht für den Montag, der Wert 7 für den Sonntag). Das Prüfbit 1 ergänzt die Bits 21 bis 27 auf gerade Parität, d.h. es werden die High-Bits 21 bis einschließlich 28 addiert, deren Ergebnis muss dann eine gerade Zahl ergeben. Das Prüfbit 2 ergänzt die Parität von Bit 29 bis 34, während Prüfbit 3 für die Parität der Bits 36 bis 57 zuständig ist. Diese Prüfbits sind ein erstes Überprüfungskriterium für ein DCF-Empfangsprogramm, welches damit zunächst auf einfache Weise die Konformität der empfangenen Daten überprüfen kann. Für eine fehlerfreie DCF-Decodierung sind allerdings noch weitere Maßnahmen notwendig. (Zum Beispiel ein Vergleich der soeben dekodierten Uhrzeit und des Datums mit der Uhrzeit und dem Datum welches mit der vorhergehenden Minute übertragen wurde und zusätzlich noch eine mitlaufende Softwareuhr). In unregelmäßigen Zeitabständen muss eine Schaltsekunde eingefügt werden. Dies ist dadurch bedingt, dass sich die Erde nicht genau in 24 Stunden um sich selbst dreht. Auf die koordinierte Weltzeitskala UTC bezogen, wird diese Korrektur zum Ende der letzten Stunde des 31. Dezember oder 30. Juni vorgenommen. In Mitteleuropa muss die Schaltsekunde daher am 1. Januar um 1.00 Uhr MEZ oder am 1.Juli um 2.00 MESZ eingeschoben werden. Zu den genannten Zeiten werden daher 61 Sekunden gesendet. Seite 7

8 3. Schaltungsbeschreibung (DCF-Uhr) Bild 3.1.: Schaltung Seite 8

9 Die Schaltung sieht auf dem ersten Blick vielleicht etwas umfangreich aus, ist aber eigentlich sehr einfach. Es handelt sich um einige Standardlösungen. Der größte Bauteil ist das CPLD (IC1). Dieser benötigt neben der Versorgungsspannung (Anschlüsse VCCxx und GND) zunächst eine Reset- Beschaltung und eine Takt-Beschaltung. Die Reset-Beschaltung besteht aus einem einfachen RC-Glied bestehend aus dem Widerstand R1 und dem Elektrolyt-Kondensator C1. Dieses RC-Glied bewirkt bei jedem Einschalten einen Reset. Die Takt-Beschaltung ist schon etwas umfangreicher. Sie besteht aus einem speziellen Inverter (IC2), einem 32,768kHz-Quarz (X1) zwei Kondensatoren (C2 und C3) und zwei Widerständen (R2 und R3) 8. Der eher unübliche Wert für den Quarz von 32,768kHz wurde deswegen gewählt, weil daraus sehr einfach ein 1-Hz-Takt erzeugt werden kann. Dieser 1-Hz wird im CPLD für die Uhr benötigt. (siehe auch Abschnitt 4.3.). Wichtig: Für IC2 muss unbedingt der in der Stückliste angegebene Typ 74HCU04 verwendet werden. Die Ausgabe der Uhrzeit erfolgt mit 7-Segment-Anzeigen (LD1 bis LD5). LD5 beinhaltet zwei solche 7-Segment-Anzeigen, während LD1 bis LD4 nur jeweils eine beinhalten, dafür sind diese aber etwas größer. Für jede 7-Segment-Anzeige ist jeweils ein eigener Dekoder-IC notwendig (IC3 bis IC8 vom Typ 74LS47). Diese Dekoder haben die Aufgabe die richtigen Segmente einer 7-Segment-Anzeige anzusteuern. Weiters sind für jedes Segment der 7-Segment-Anzeige Vorwiderstände notwendig (R5 bis R18 und R21 bis R48). Dabei fällt auf, dass die Vorwiderstände R35 bis R48 einen größeren Wert besitzen. Dies liegt daran, dass unterschiedliche 7-Segment-Anzeigen verwendet wurden, die unterschiedlich stark leuchten. Durch diese unterschiedlichen Widerstandswerte wird erreicht, dass trotzdem alle Anzeigen in etwa gleich hell leuchten. Die Dekoder-ICs besitzen einige Steuerleitungen, die hier zu besonderen Effekten führen. Mit dem Steuereingang RBI (Pin 5) wird die 7-Segment-Anzeige nur dann aktiv, wenn sie einen Wert größer als 0 anzeigen soll. Mit anderen Worten: eine 0 wird nicht angezeigt. Dies wird hier bei der Zehnerstelle der Stundenanzeige ausgenützt. Die übrigen 7-Segment-Anzeigen verwenden den Steuereingang BI/RB0 (Pin 4). Mit diesem kann die Anzeige ein- und ausgeschaltet werden. Bei diesem Projekt erzielt man damit, dass die Anzeige erst dann eingeschaltet wird, wenn ein gültiges DCF-Telegramm empfangen wurde. Die Leuchtdioden D1 und D2 mit den Vorwiderständen R19 und R20 dienen zur Anzeige des Sekundentakts zwischen der Stunden- und Minutenanzeige. Die Leuchtdioden D3 bis D9 mit den Vorwiderständen R49 bis R55 dienen zur Anzeige von Statusinformationen. Diese sind optional und können mit den Jumpern JP1 bis JP7 ausgeschaltet werden. Die Leuchtdioden D8 und D9 haben hier noch keine Bedeutung, sie sind aber für weitere Zwecke vorhanden, da noch genügend Ein/Ausgabepins vorhanden sind. IC9 dient hier zur Isolierung, da Verbraucher (Leuchtdioden, Relais, Motoren etc.) nicht direkt an das CPLD angeschlossen werden sollen. Der 10polige Anschluss JTAG (K1) dient zum Programmieren des CPLD. 8 Eine genauere Beschreibung zu dieser Takt-Schaltung finden Sie im Buch 306 Schaltungen (ISBN: ), Seite 399f Seite 9

10 Zur Dekodierung des DCF-Telegramms dient ein bei Conrad erhältliches DCF- Empfangsmodul (Bestell-Nr.: ). Dieses Modul enthält eine Empfangsantenne und einen Demodulator, so dass am Ausgang des Moduls das übertragene Zeittelegramm mit einem CPLD ausgewertet werden kann. Bild 3.2. zeigt dieses DCF- Empfangsmodul. Bild 3.2.: DCF-Empfangsmodul Der Ausgangsstrom von nur einem Milliampere ist für die Kontroll-Leuchtdiode (D12) zuwenig. Die nachgeschaltete Transistorstufe (T1) mit den Widerständen R56 und R58 gleicht diesen Nachteil aus. Der Widerstand R57 dient als Vorwiderstand für die Leuchtdiode (D12). Diese Leuchtdiode signalisiert den empfangenen Datenstrom, wenn der Jumper JP9 gesteckt ist. Bei einem korrekten Empfang blinkt diese Leuchtdiode im Sekundentakt. Dieses Blinken zeigt sozusagen den Ausgangspegel der Anpass- Schaltung an. Das Puls-Pausen-Verhältnis (Leuchtzeit/Dunkelzeit der Leuchtdiode D12) entspricht der im Abschnitt 2 genannten Zeiten. Bei etwas Übung kann der Unterschied zwischen Low (100ms Absenkung des Trägers, LED ist 100ms dunkel) und High (200ms Absenkung des Trägers, LED ist 200ms dunkel) optisch erkannt werden. Der Kondensator C16 dient zur Entkoppelung der Betriebsspannung für das DCF- Modul. Für diesen Koppelkondensator sollte ein Keramiktyp verwendet werden. Dieser muss möglichst nahe am DCF-Modul angebracht werden. Für die Stromversorgung wurde ebenfalls eine Standardschaltung bestehend aus dem Festspannungsregler (IC10) vom Typ 7805 und den Kondensatoren C4 bis C7 gewählt. Da die 7-Segment-Anzeigen und das CPLD einiges an Strom benötigen, wird der Festspannungsregler schon ziemlich warm. Daher sollte dieser mit einem Kühlkörper (gemäß Stückliste im Anhang B) versehen werden. Die Diode D10 dient als Verpolungsschutz und die Leuchtdiode D11 zeigt an, ob die DCF-Uhr mit Spannung versorgt ist. Die Kondensatoren C8 bis C12 dienen zur Entkoppelung der Betriebsspannung für IC2 bis IC9. Für diese Koppelkondensatoren sollten Keramiktyp verwendet werden. Diese sollten möglichst nahe an den ICs angebracht werden. Seite 10

11 4. Softwareentwurf mit CPLDs am Beispiel DCF-Uhr 4.1. Grundlagen Komplexe digitale Schaltungen sind stets eine Zusammensetzung aus kombinatorischer Logik 9 (in Form von Addierer, Adressdekodierer, Multiplexer und Demultiplexer, usw.) und sequentieller Logik 10 (in Form von Zählern, Schieberegister, diskreten FlipFlops und Zustandsmaschinen). Es ist daher unbedingt notwendig, dass man diese digitalen Grundschaltungen beherrscht Einteilung der Aufgabe in Blöcke Bei der Entwicklung von Schaltungen mit CPLDs gibt es eine Vielzahl von Ansätzen und Vorgehensweisen. Eine davon ist die so genannte Top-Down-Methode. Bei dieser Methode wird der gesamten Prozess in Blöcke unterteilen. Diesen Blöcken ordnet man bestimmte Aufgaben zu, wobei man sich vorerst noch nicht um deren Innenleben zu kümmern braucht. Auf dieser Ebene denkt man über den gesamten Prozess nach und versucht dabei das Zusammenspiel dieser Blöcke zu optimieren. Erscheint einem diese Aufteilung optimal, so Unterteilt man die einzelnen Blöcke wieder in Unterblöcke. Dabei geht man genau so vor, wie in der ersten Ebene. Nun kann man sich auf die Aufteilung dieser bereits kleineren Blöcke konzentrieren und muss sich nicht mehr so intensiv mit dem gesamten Prozess kümmern. Diese Vorgehensweise wiederholt man so lange, bis man schließlich bei Blöcken mit einer überschaubaren Größe angekommen ist. Diese Blöcke können dann meist als einfache Zustandsmaschinen oder als kombinatorische Logik realisiert werden Einteilung in Blöcke am Beispiel der DCF-Uhr Bevor man die gestellte Software-Aufgabe in Blöcke einteilen kann, muss man sich zuerst im Klaren sein, was denn die Software alles erledigen muss, und wie man diese am besten und sinnvollsten realisiert. (Dabei spielt sicher auch die Erfahrung eine wichtige Rolle!) Hier, bei der DCF-Uhr hat die Software (im Zusammenspiel mit der Hardware) folgende Aufgaben: Aus dem seriellen DCF-Datenstrom (Eingangspin 55) Low, High Minutenwechsel ermitteln. (gemäß Abschnitt 2. Grundlegendes zu DCF). Diese Informationen zwischenspeichern und an den Ausgängen 51 (für Low ) und 52 (für High ) ausgeben. Bei einem fehlerhaften Empfang (d.h. wenn weder ein Low, ein High oder ein Minutenwechsel erkannt wurde, die Fehler Ausgänge 41 und 49 setzen. Eine frei mitlaufende Uhr, welche ständig mit einer gültigen Uhrzeit aus dem DCF- Empfang synchronisiert wird. Eine gültige Uhrzeit liegt vor, wenn ein DCF- Telegramm fehlerfrei empfangen wurde. 9 Kombinatorische Logik wird oft auch mit Schaltwerke bezeichnet 10 Sequentielle Logik wird oft auch mit Schaltnetze bezeichnet Seite 11

12 Die Anzeige der Uhrzeit soll erst dann erfolgen, wenn ein gültiges DCF-Telegramm empfangen wurde. (Ausgangspin 16). Dies soll außerdem am Ausgang Sync (Pin 45) angezeigt werden. Die Uhrzeit in BCD-Form ausgeben. Alle Eingänge mit dem Takt synchronisieren. Dies erfolgt normalerweise mit einem einfachen D-FlipFlop. Anmerkung: Die DCF-Uhr besitzt nur einen Eingang, folglich ist nur ein D-FlipFlop notwendig. Bild 4.1. zeigt die Blockeinteilung für die DCF-Uhr. Bei dieser ersten Aufteilung spricht man auch vom Top-Design oder Top-Level-Design. Bild 4.1.: Top-Level-Design (DCF-Uhr) Hier, bei der DCF-Uhr erfolgt das Top-Level-Design aus zwei Blöcken. Anmerkung: Die hier getroffene Blockeinteilung ist sicher nur eine Möglichkeit von mehreren. Hier liegt die Freiheit des Entwicklers, die geforderte Aufgabe in sinnvolle Teilaufgaben zu zerlegen, was mitunter auch ein wenig Erfahrung benötigt. Block DCF-Dekodierung Dieser Block hat die Haupt-Aufgabe aus dem seriellen DCF-Datenstrom das Telegramm (Low- und High-Bits) zu ermitteln und diese zwischenzuspeichern. Die Bilder 4.2. und 4.3. zeigen die Realisierung dieses Blocks. Dieser Block besteht aus einer Zustandsmaschine (izm_dcf), einem Zähler (izaehler_dcf) zur Ermittlung von Zeiten, einem Schiebregister (isr_dcf) zur Speicherung des Telegramms, und einigen D-FlipFlops zur Speicherung diverser Zustände und zur Synchronisierung des DCF-Eingangs mit dem Systemtakt (iff_dcf_in). Seite 12

13 Bild 4.2.: Block DCF-Dekodierung Die Hauptaufgabe der Zustandsmaschine (izm_dcf) ist es aus dem seriellen Datenstrom am Eingang die LOWs und HIGHs zu ermitteln. Gemäß Abschnitt 2 erfolgt zu jeder Sekunde ein Impuls. Ein Low-Impuls dauert zwischen 80ms und 120ms und ein High-Impuls zwischen 160ms und 240ms. Bei einem Minutenwechsel bleibt dieser Impuls aus. Bild 4.3 (links oben) zeigt noch einmal diesen Zusammenhang. Für die Auswertung ist aber nicht diese Impulszeit interessant, sondern vielmehr die Zeit zwischen zwei Impulsen (siehe Bild 4.3, links oben). Denn mit dieser Zeit kann eindeutig zwischen einem Low, einem High und einem Minutenwechsel unterschieden werden. Die Grundidee ist nun die, dass, diese Zeit mit Hilfe eines Zählers (izaehler_dcf im Bild 4.2.) gezählt wird, wobei der Zähler bei einer steigenden Flanke am Eingang freigegeben (also gestartet wird) und bei einer fallenden Flanke am Eingang wird der Zählwert eingelesen und ausgewertet. Im Zustandsdiagramm (Bild 4.3.) sind dies die Zustände Z0, Z1 und Z2. Erfolgt aber nach einer gewissen Zeit keine fallende Flanke, so erfolgt ein Time-Out, also ein Fehler. Gemäß Zustandsdiagramm (Bild 4.3.) erfolgt dann nach dem Zustand Z1 der Zustand Z7, wo die beiden Fehler- FlipFlops (iff_dcf_bitfehler und iff_dcf_fehler) gesetzt werden. Anschließend gelangt die Zustandsmaschine in den Ausgangszustand (Z0) zurück und wartet auf die nächste steigende Flanke. Seite 13

14 Bild 4.3.: Zustandsdiagramm izm_dcf Erfolgt aber eine fallende Flanke am Eingang innerhalb der Time-Out-Zeit, so gelangt die Zustandmaschine nun zum Zustand Z2. hier erfolgt die Auswertung des Zählerstands des Zählers izaehler_dcf. Entspricht der Zählerstand dieses Zählers einem Wert zwischen (entspricht 880 ms) und (entspricht 920 ms), so wurde ein LOW empfangen. Daher folgt auf den Zustand Z2 nun der Zustand Z3, wo dem Schieberegister (isr_dcf) ein LOW hinzugefügt wird. Weiters wird das FlipFlop iff_dcf_lo gesetzt, zur Kennzeichnung, dass ein Low empfangen wurde, während die FilpFlops iff_dcf_high und iff_dcf_bitfehler gelöscht werden. Anschließend gelangt die Zustandsmaschine in den Ausgangszustand (Z0) zurück und wartet auf die nächste steigende Flanke. Entspricht der Zählerstand dieses Zählers einem Wert zwischen (entspricht 760 ms) und (entspricht 840 ms), so wurde ein HIGH empfangen. Daher folgt auf den Zustand Z2 nun der Zustand Z4, wo dem Schieberegister (isr_dcf) ein HIGH hinzugefügt wird. Weiters wird das FlipFlop iff_dcf_high gesetzt, zur Kennzeichnung, dass ein High empfangen wurde, während die FilpFlops iff_dcf_lo und iff_dcf_bitfehler gelöscht werden. Anschließend gelangt die Zustandsmaschine in den Ausgangszustand (Z0) zurück und wartet auf die nächste steigende Flanke. Entspricht der Zählerstand dieses Zählers einem Wert zwischen (entspricht 1760 ms) und (entspricht 1920 ms), so wurde ein Minutenwechsel empfangen. Daher folgt auf den Zustand Z2 nun der Zustand Z5, wenn das Fehler- FlipFlop iff_dcf_fehler nicht gesetzt ist, oder der Zustand Z6, wenn das Fehler- FlipFlop iff_dcf_fehler gesetzt ist. Diese Unterscheidung hat folgende Gründe: o Ist das Fehler-FlipFlop iff_dcf_fehler nicht gesetzt, so bedeutet dass, das ein komplettes DCF_Telegramm fehlerfrei empfangen wurde, da ja sobald ein Fehler auftritt dieses Fehler-FlipFlop gesetzt wird o Zu Beginn (also nach dem Einschalten) ist das Fehler-FlipFlop gesetzt (der Set-Eingang dieses FlipFlops ist ja mit der Reset-Leitung verbunden, Seite 14

15 siehe Bild 4.2.). Das bedeutet, dass zunächst auf einen Minutenwechsel gewartet werden muss. Im Zustand Z5 wird die frei mitlaufende Uhr mit der empfangenen DCF-Uhrzeit (und Datum) synchronisiert. Die Daten (Uhrzeit und Datum) befinden sich ja nun im Schieberegister und können an den entsprechenden Ausgängen abgegriffen werden. Bild 4.4. zeigt, welche Daten an welchen Ausgängen des Schieberegisters anliegen. Weiters wird im Zustand Z5 das FlipFlop iff_dcf_sync gesetzt. Diese zeigt an, dass die DCF-Uhr nun synchronisiert ist. Anschließend gelangt die Zustandsmaschine in den Ausgangszustand (Z0) zurück und wartet auf die nächste steigende Flanke. Der Zustand Z6 hat nur die Aufgabe, das Fehler-FlipFlop iff_dcf_fehler wieder zurückzusetzen. In diesem Fall wird die frei mitlaufende Uhr nicht mit den Daten vom Schieberegister synchronisiert, da die Daten im Schieberegister fehlerhaft sind. Anschließend gelangt die Zustandsmaschine in den Ausgangszustand (Z0) zurück und wartet auf die nächste steigende Flanke. Bild 4.4.: Schieberegister isr_dcf Seite 15

16 Noch eine Anmerkung zum Zähler izaehler_dcf: Der Systemtakt beträgt, wie schon im Abschnitt 3 erläutert, f = 32,768 khz. Da der Zähler izaehler_dcf mit diesem Takt getaktet wird ergibt sich eine Zeit T von T = 1 = f s Für eine Zeit von Beispielsweise t = 880ms (wie oben erwähnt) ergibt sich somit ein Zählerstand von Zählerwert = Also ein Zählwert von t T = t f = 0,88 s s 1 = 28835,84 Achtung: Der Nachteil bei dieser Auswertemethode ist, dass die Uhr um 1 Sekunde nachgeht, da ja die Auswertung am Ende der Sekunde erfolgt, und da beginnt ja schon die neue Sekunde. Im Allgemeinen spielt dass aber nur eine sehr untergeordnete Rolle. Block Freilaufende Uhr Dieser Block hat die Haupt-Aufgabe eine (freilaufende) Uhr zu erzeugen, welche auch geladen werden kann. Die einfachste Realisierung einer Uhr besteht darin Zähler hintereinander zu schalten, wobei der Ausgang des ersten Zählers der Takt für den zweiten Zähler ist, der Ausgang des zweiten Zählers der Takt für den nächsten Zähler usw. Diese asynchrone Methode wird als Ripple-Counter bezeichnet. Ihr größter Vorteil ist ihre Einfachheit. Ihre Nachteile sollten aber auch nicht unerwähnt bleiben. Diese asynchrone Methode eignet sich nur für niedrige Frequenzen und es können beim Übergang von einem Zählwert zum nächsten Zählwert kurzzeitig falsche Zählwerte auftreten. Beide Nachteile sind bei dieser Anwendung als DCF-Uhr aber von untergeordneter Rolle, da der Systemtakt mit kHz sehr gering ist, und die Uhrzeit nur mit 7-Segment-Anzeigen angezeigt werden soll. Unser menschliches Auge bekommt es gar nicht mit, wenn kurzzeitig (kurzzeitig bedeutet hier im 10ns-Bereich) eine falsche Uhrzeit angezeigt wird. Bild 4.5. zeigt die Realisierung der freilaufenden Uhr. Bild 4.5.: Block Freilaufende Uhr Seite 16

17 Dieser Block wird hier wieder in mehrere Blöcke gemäß Abschnitt 4.2 aufgeteilt. Hier handelt es sich im Wesentlichen um verschiedene Zähler. Die Aufgabe des ersten Zählers ist die Erzeugung eines 1-Sekunden-Taktes aus dem Systemtakt. Die nächsten drei Blöcke sind für die Uhrzeit zuständig. Hier handelt es sich jeweils um BCD-Zähler von 0 bis 59 (für Sekunden und Minuten) bzw. von 0 bis 23 (für die Stunden). Neben dem Systemtakt (clock_dcf) sind noch die Leitungen Uhr freigeben, Laden und das dekodierte DCF-Telegramm vorhanden. Die freilaufende Uhr soll erst dann mit ihrer Arbeit beginnen, wenn ein gültiges DCF-Telegramm empfangen wurde. Erst ab diesem Zeitpunkt wird die Anzeige mit der Leitung Uhr freigeben aktiviert und die freilaufende Uhr beginnt unabhängig von der DCF-Dekodierung zu laufen, wobei aber jedes Mal wenn ein gültiges DCF-Telegramm empfangen wurde die Uhr (also die Zähler) mit den Daten aus dem DCF-Telegramm überschrieben werden. Dazu ist die Leitung Laden zuständig. Weiters soll die Leitung Laden auch den Sekundenzähler und den Zähler für den Sekundentakt löschen. Block Zähler für Sekundentakt Dieser Block hat die Aufgabe aus dem Systemtakt (32.768kHz) einen 1-Sekunden-Takt zu erzeugen. Wenn man bedenkt, dass nichts anderes als 2 15 ist, und man außerdem weiß, dass jede Stufe eines Binärzähler durch 2 dividiert, so liegt es nahe für diese Aufgabe einen 15-Stufigen-Binärzähler zu verwenden. Altera bietet in seiner Entwicklungsumgebung (Quartus) u.a. solche Zähler (lpm_counter) an, welche noch über einige Zusatzfunktionen (wie Zähler freigeben, Zähler löschen, Zähler laden usw.) verfügen. Diese Zusatzfunktionen kommen uns sehr gelegen, da wir diese hier teilweise verwenden, denn dieser Zähler soll wie Bild 4.5. zeigt, freigegeben und gelöscht werden können. Block BCD-Zähler 0-59 (Sekunden) Bild 4.6. zeigt einen BCD-Zähler für die Sekunden. Dieser besteht aus einem 4-Bit- Zähler für die Sekunden-Einer (izaehler_sek_e) und einem 3-Bit-Zähler für die Sekunden-Zehner (izaehler_sek_z), wobei diese Zähler aber nicht ihren gesamten Zählbereich (0 bis 15 bzw. 0 bis 7) ausnützen sondern nur den für Sekunden sinnvollen Bereich von 0 bis 9 (Einer) und 0 bis 5 (Zehner). Diese Eigenschaft lässt sich in der Software für jeden Zähler angeben. (siehe Abschnitt 5, Schritt 2) Die Steuerleitung Laden setzt beide Zähler zurück. Bild 4.6.: Block BCD-Zähler 0-59 (Sekunden) Der Takt für den Sekunden-Einer-Zähler (izaehler_sek_z) stammt vom Block Zähler für Sekundentakt (siehe Bild 4.5.). Als Takt für den Sekunden-Zehner-Zähler (izaehler_sek_z) dient der höchstwertige Ausgang (q[3]) des Sekunden-Einer- Seite 17

18 Zählers (izaehler_sek_e) in negierter Form (siehe Bild 4.6). Bild 4.7. zeigt weshalb. Beim Übergang von 9 nach 0 des Sekunden-Einer-Zählers geht der Ausgang q[3] von high nach low. Da dies der einzige high-low-übergang von q[3] ist und dieser genau dann auftritt wenn der Zählstand der Sekunde von 9 nach 0 übergeht kann dieser als Takt für die Zehner-Stelle dienen. Allerdings in negierter Form. Bild 4.7.: Zeitdiagramm des Zählers für die Einerstelle der Sekunde Ähnliches gilt als Takt für den nachfolgenden Minuten-Zähler-Block. Als Takt für den Minuten-Einer-Zähler (izaehler_min_e) dient der höchstwertige Ausgang (q[2]) des Sekunden-Zehner-Zählers (izaehler_sek_z) in negierter Form (siehe Bild 4.5). Bild 4.8. zeigt weshalb. Beim Übergang von 5 nach 0 des Sekunden-Zehner-Zählers geht der Ausgang q[2] von high nach low. Da dies der einzige High-Low-Übergang von q[1] ist und dieser genau dann auftritt wenn der Zählstand der Minute von 5 nach 0 übergeht kann dieser als Takt für die Einer-Stelle für die Minute dienen. Allerdings in negierter Form. Bild 4.8.: Zeitdiagramm des Zählers für die Zehnerstelle der Sekunde Block BCD-Zähler 0-59 (Minuten) Bild 4.9. zeigt einen BCD-Zähler für die Minuten. Auch dieser Block besteht aus einem 4-Bit-Zähler (für die Minuten-Einer, izaehler_min_e) und einem 3-Bit-Zähler (für die Minuten-Zehner, izaehler_min_z). Der Unterschied zum Block BCD-Zähler 0-59 (Sekunden) ist, dass diese beiden Zähler geladen werden können. Und zwar mit der Minuten-Information aus dem DCF-Telegramm. Die Steuerleitung Laden hat also hier die Aufgabe die beiden Zähler mit den anliegenden Daten aus dem DCF-Telegramm zu laden. Diese Daten liegen an den Zähler-Eingängen data[3..0] (für die Einerstelle) bzw. data[2..0] für die Zehnerstelle an. Als Takt für Einerzähler dient, wie schon vorher erwähnt, der höchstwertige Zählerausgang des Zählers für die Sekunden-Zehnerstelle (q[2]), allerdings in negierter Form. Als Takt für den Minuten-Zehner-Zähler dient der höchstwertige Ausgang (q[3]) des Minuten-Einer-Zählers (izaehler_min_e) in negierter Form (siehe Bild 4.9). Auch hier gelten die gleichen Überlegungen wie für den Block BCD-Zähler 0-59 (Sekunden). Seite 18

19 Bild 4.9.: Block BCD-Zähler 0-59 (Minuten) Block BCD-Zähler 0-23 (Stunden) Bild zeigt einen BCD-Zähler für die Stunden. Auch dieser Block besteht aus einem 4-Bit-Zähler (für die Stunden-Einer, izaehler_std_e) und einem 2-Bit-Zähler (für die Stunden-Zehner, izaehler_std_z). Bild 4.10.: Block BCD-Zähler 0-23 (Stunden) Die Besonderheit bei diesem BCD-Zähler ist, dass dieser nur bis 23 zählen soll. Dies erreicht man dadurch, indem man, sobald der BCD-Zähler zum Wert 24 gelangt beide Zähler löscht. Diese Aufgabe übernimmt das UND-Gatter (siehe Bild 4.10). Der Ausgang dieses UND-Gatters ist mit den Lösch-Eingängen (.aclr) der beiden Zähler verbunden. D.h. sobald beide Eingänge am UND-Gatter logisch high sind wird der Zähler gelöscht und beginnt wieder beim Wert 0 zu zählen. Das Zeitdiagramm (Bild 4.11.) zeigt uns warum q[2] der Einerstelle und q[1] der Zehnerstelle als Auslöser für das Löschen der Zähler zu verwenden sind. Seite 19

20 Bild 4.11.: Zeitdiagramm (BCD-Zähler 0-23, Stunden) Die Kombination q[2] (Einer) = 1 und q[1] (Zehner) = 1 tritt wie im Bild zu erkennen nur beim BCD-Zählwert 24 auf. Der Nachteil bei dieser Methode ist, dass kurzzeitig der Wert 24 am Ausgang des BCD-Zählers ansteht. Hier, bei dieser Anwendung als einfach DCF-Uhr, welche nur die Uhrzeit anzeigen soll ist dieser Nachteil nicht von großer Bedeutung, da die Zeit, wo dieser falsche Wert angezeigt wird nur sehr, sehr gering ist (im ns-bereich), und daher vom menschlichen Auge gar nicht wahrgenommen wird. Beginnt man nun mit den zuletzt beschriebenen Blöcken und fügt man diese in den jeweils übergeordneten Block ein, also die Bilder 4.10., 4.9. und 4.6. in 4.5., diesen und 4.2. in das Top-Level-Design (Bild 4.1.) so ergibt sich das fertige Design. Bild 4.12a. zeigt dieses fertige Gesamtdesign für die Anwendung des CPLD als DCF-Uhr. Bild 4.12b. zeigt nochmals die Zustandsmaschine (izm_dcf) vom Bild 4.3. Seite 20

21 Bild 4.12a. Gesamtdesign Seite 21

22 Bild 4.12b.: Gesamtdesign (Zustandsdiagramm izm_dcf ) Seite 22

23 5. Umsetzung des Designs in AHDL Als nächster Schritt erfolgt nun die Umsetzung des am Papier entworfenen Designs (hier für die DCF-Uhr) in eine für das CPLD verständliche Sprache. Hierfür gibt es mehrere Möglichkeiten. Eine Möglichkeit wäre die Eingabe in Form eines Schaltplans. Diese Methode wird aber selten verwendet, da sie sehr zeitintensiv ist. Eine andere Methode ist die Verwendung einer so genanten Hardware-Beschreibungssprache (engl. HDL für Hardware Description Language). Da hier ein CPLD des Herstellers Altera verwendet wird liegt es nahe die von Altera entwickelte Variante AHDL zu verwenden. Weiters ist eine Entwicklungsumgebung notwendig. Hier fiel die Wahl auf das von Altera entwickelte Entwicklungssystem Quartus (Version II 5.0 Web-Edition), welches kostenlos vom Internet unter gedownloadet werden kann. Nach der Installation dieses Programms ist eine kostenlose Lizenz notwendig. (Durch umgehen dieser Lizenz kann zwar ein Design erstellt und kompiliert werden, es ist aber nicht möglich dieses Design in ein CPLD zu programmieren) Die nun folgenden Schritte sollen zeigen, wie man ein neues Projekt (mit Quartus) erstellt, welche Einstellungen notwendig sind, wie man das Design (vom Bild 5.12.) mit AHDL beschreibt, usw. Zu diesen Schritten existiert in der Online-Hilfe ein sehr gutes Tutorial (allerdings nur in englischer Sprache) Schritt 1: Ein neues Projekt in Quartus anlegen Quartus starten. Nach einer Weile erscheint der Startbildschirm (nach Bild 5.1) Bild 5.1.: Startbild der Entwicklungssoftware Quartus (hier II Version 5.0) Seite 23

24 Durch anklicken von File und New Project Wizard wird ein Dialog zur Erstellung eines neues Projektes gestartet. Es erfolgt zunächst eine Einführung über folgenden durch zu führenden Schritte (Bild 5.2) Bild 5.2.: Dialog zur Erstellung eines neuen Projekts (Einführung) Taste Next > Bild 5.3.: Dialog zur Erstellung eines neuen Projekts (Schritt 1) Hier erfolgt die Auswahl des Projekt-Ordners, des Projekt-Namens und des Namens des Top-Level-Designs. Anmerkungen: Für den Projekt-Namen und für den Namen des Top-Level-Designs sollten sprechende Namen verwendet, so dass man schon an diesen Namen erkennt worum es bei diesem Projekt geht. Für beide kann durchaus, so wie hier, der gleiche Name gewählt werden. Taste Next > 4 Seite 24

25 Bild 5.4.: Dialog zur Erstellung eines neuen Projekts (Schritt 2) Hier können schon vorhanden Design-Files in das Projekt eingebunden werden. Bei diesem Projekt gehen wir davon aus, dass noch keine Design-Files vorhanden sind. Die Eingabefelder bleiben daher leer. Taste Next > Bild 5.5.: Dialog zur Erstellung eines neuen Projekts (Schritt 3) Nun wird das CPLD ausgewählt. Wir verwenden hier ein Mitglied der MAX7000S- Familie (1). Mit dem Filter (2) kann die Suche nach dem verwendeten Typ erleichtert werden. Da wir hier den Typ EPM7128SLC84-15 verwenden wählen wir diesen auch aus (3). Siehe auch Schaltungsbeschreibung (Abschnitt 3) und Stückliste (Anhang B) Taste Next > 4 Seite 25

26 Bild 5.6.: Dialog zur Erstellung eines neuen Projekts (Schritt 4) Hier können weitere (spezielle) Werkzeuge ausgewählt werden. Wir benötigen hier keine. Taste Next > Bild 5.7.: Dialog zur Erstellung eines neuen Projekts (Schritt 5, Zusammenfassung) Abschließend erfolgt eine Zusammenfassung über die gewählten Einstellungen. Taste Finish Seite 26

27 1 2 Bild 5.8.: Arbeitsbereich nach dem Erstellen eines neuen Projekts Bild 5.8. zeigt wieder den Arbeitsbereich der Entwicklungsumgebung. Im Gegensatz zum Startbild (Bild 5.1) zeigt dieses nun ganz oben den Projekt-Ordner, den Projektnamen und den Namen des Top-Level-Designs an (1) und im Abschnitt Project Navigator befindet sich das gewählte CPLD (hier: EPM7128SLC84-15) und der Name des Top-Level-Design (hier: dcf) (2). Nun folgt die Eingabe des Designs in der Sprache AHDL. Schritt 2: Eingabe des Designs in AHDL Durch anklicken von File und New kann neues Design-File dem Projekt hinzugefügt werden. Bild 5.9. zeigt eine Liste mit den möglichen Design-Arten. Wir wollen unser Design in AHDL erstellen und wählen daher AHDL File aus (1). Anschließend OK (2). 1 2 Bild 5.9.: Design-File-Auswahl Seite 27

28 Bild 5.10 zeigt nun den neuen Arbeitsbereich. Im neuen Fenster erfolgt nun die Eingabe der Code-Zeilen. Bild 5.10.: Arbeitsbereich Da wir unser Design in AHDL beschreiben wollen, zunächst den grundlegenden Aufbau eines AHDL-Design-Files. SUBDESIGN xxx ( ) Name des Designs Hier werden alle Ein- und Ausgänge definiert. VARIABLE BEGIN END; Werden im Design FlipFlops, Zähler, Schieberegister, usw. verwendet, so werden diese hier definiert und ggf. parametrisiert. In diesem Block befindet sich die Beschreibung der Schaltung. Auf den folgenden Seiten ist nun das AHDL-File für die DCF-Uhr in Form eines Listings zu sehen. Man erkennt den soeben erwähnten Aufbau. Zur besseren Orientierung habe ich auch die Zeilennummern angegeben, so wie sie auch in der Entwicklungsumgebung angezeigt werden: In Zeile 27 erkennt man den Namen des Designs, hier:subdesign dcf. In den Zeilen 29 bis 52 werden alle Ein- und Ausgänge definiert (Anmerkung: Die Zuweisung der Pinnummern erfolgt an anderer Stelle, siehe Schritt 5) In den Zeilen 57 bis 147 erfolgt die Definition und Einstellung aller verwendeten Flipflops, Zähler, Schieberegister und der Zustandsmaschine. Ab Zeile 151 (bis zum Ende) beginnt schließlich die Beschreibung der Schaltung. Seite 28

29 Listing (dcf.tdf) 1 %****************************************************************************% 2 %* DCF-Dekodierung (ohne Datum) (in AHDL) mit EPM7128S und 32,768-kHz-Takt *% 3 %* *% 4 %* Entwickler: Buchgeher Stefan *% 5 %* Entwicklungsbeginn: 28. Dezember 2004 *% 6 %* Funktionsfaehig seit: 3. Mai 2005 *% 7 %* Letzte Bearbeitung: 15. September 2005 *% 8 %****************************************************************************% 9 10 %***************** Include-Dateien ******************************************% 11 INCLUDE "lpm_counter.inc"; 12 INCLUDE "lpm_shiftreg.inc"; %***************** Konstanten ***********************************************% 16 CONSTANT KONSTDCFLMIN = 28835; % entspricht 880 ms % 17 CONSTANT KONSTDCFLMAX = 30147; % entspricht 920 ms % 18 CONSTANT KONSTDCFHMIN = 24903; % entspricht 760 ms % 19 CONSTANT KONSTDCFHMAX = 27526; % entspricht 840 ms % 20 CONSTANT KONSTDCFMINMIN = 57671; % entspricht 1760 ms % 21 CONSTANT KONSTDCFMINMAX = 62915; % entspricht 1920 ms % 22 CONSTANT KONSTDCFTIMEOUT = 65400; % Time-Out % 23 CONSTANT KONST_ANZ_SR = 36; % % %***************** Definition der Ein- und Ausgaenge ************************% 27 SUBDESIGN dcf 28 ( 29 clock_dcf : INPUT; % System-Takt % reset : INPUT; indcf_in : INPUT; % DCFIN % outsek_takt, 36 outdcf_fehler : OUTPUT; % Zustandsanzeige "FEHLER" % 37 outdcf_sync : OUTPUT; % Zustandsanzeige "SYNC" % outdcf_bitfehler, % Zustandsanzeige "?" % 40 outdcf_lo, % Zustandsanzeige "LO" % 41 outdcf_hi : OUTPUT; % Zustandsanzeige "HI" % outanzeige_en : OUTPUT; % Aktiviert die Anzeige % outsek_e[3..0], 46 outsek_z[2..0] : OUTPUT; % Sekunden im BCD-Format % outmin_e[3..0], 49 outmin_z[2..0] : OUTPUT; % Minuten im BCD-Format % outstd_e[3..0], 52 outstd_z[1..0] : OUTPUT; % Stunde im BCD-Format % 53 ) %***************** Definition der Variablen *********************************% 57 VARIABLE 58 % D-FlipFlops % 59 iff_dcf_in : DFF; % D-Flipflop zur Synchronisierung des 60 DCF-Eingangs % 61 iff_dcf_fehler : DFFE; 62 iff_dcf_sync : DFFE; 63 iff_dcf_lo : DFFE; 64 iff_dcf_hi : DFFE; 65 iff_dcf_bitfehler : DFFE; Seite 29

30 68 % 16-Bit-Zaehler % 69 izaehler_dcf : lpm_counter WITH 70 ( 71 LPM_WIDTH = 16, 72 LPM_DIRECTION = "UP" 73 ); % 15-Bit-Zaehler fuer 1-Hz-Takt % 76 izaehler_uhr : lpm_counter WITH 77 ( 78 LPM_WIDTH = 15, 79 LPM_DIRECTION = "UP" 80 ); % Sekunden - Zaehler 0-59 (BCD) % 83 izaehler_sek_e : lpm_counter WITH 84 ( 85 LPM_WIDTH = 4, 86 LPM_DIRECTION = "UP", 87 LPM_MODULUS = ); izaehler_sek_z : lpm_counter WITH 91 ( 92 LPM_WIDTH = 3, 93 LPM_DIRECTION = "UP", 94 LPM_MODULUS = 6 95 ); % Minuten - Zaehler 0-59 (BCD) % 98 izaehler_min_e : lpm_counter WITH 99 ( 100 LPM_WIDTH = 4, 101 LPM_DIRECTION = "UP", 102 LPM_MODULUS = ); izaehler_min_z : lpm_counter WITH 106 ( 107 LPM_WIDTH = 3, 108 LPM_DIRECTION = "UP", 109 LPM_MODULUS = ); % Stunden - Zaehler 0-23 (BCD) % 113 izaehler_std_e : lpm_counter WITH 114 ( 115 LPM_WIDTH = 4, 116 LPM_DIRECTION = "UP", 117 LPM_MODULUS = ); izaehler_std_z : lpm_counter WITH 121 ( 122 LPM_WIDTH = 2, 123 LPM_DIRECTION = "UP", 124 LPM_MODULUS = ); % 37-Bit-Schieberegister % 129 isr_dcf : lpm_shiftreg WITH 130 ( 131 LPM_WIDTH = KONST_ANZ_SR ); % Zustandsmaschine fuer die DCF-Dekodierung % 136 izm_dcf : MACHINE OF BITS (q[2..0]) 137 WITH STATES Seite 30

31 138 ( 139 z0 = B"000", 140 z1 = B"001", 141 z2 = B"010", 142 z3 = B"011", 143 z4 = B"100", 144 z5 = B"101", 145 z6 = B"110", 146 z7 = B"111" 147 ); %***************** Beginn der Schaltungsbeschreibung ************************% 151 BEGIN 152 % Synchronisation des DCF-Eingangs mit einem D-Flopflop % 153 iff_dcf_in.clk = clock_dcf; 154 iff_dcf_in.d = indcf_in; 155 iff_dcf_in.prn = VCC; 156 iff_dcf_in.clrn = VCC; % FlipFlops (Takt, Reset und nicht benoetigte Eingaenge) % 159 iff_dcf_fehler.clk = clock_dcf; 160 iff_dcf_fehler.prn = reset; 161 iff_dcf_fehler.clrn = VCC; iff_dcf_sync.clk = clock_dcf; 164 iff_dcf_sync.clrn = reset; 165 iff_dcf_sync.prn = VCC; iff_dcf_lo.clk = clock_dcf; 168 iff_dcf_lo.clrn = reset; 169 iff_dcf_lo.prn = VCC; iff_dcf_hi.clk = clock_dcf; 172 iff_dcf_hi.clrn = reset; 173 iff_dcf_hi.prn = VCC; iff_dcf_bitfehler.clk = clock_dcf; 176 iff_dcf_bitfehler.clrn = reset; 177 iff_dcf_bitfehler.prn = VCC; % Zaehler (Takt) % 180 izaehler_dcf.clock = clock_dcf; 181 izaehler_uhr.clock = clock_dcf; izaehler_sek_e.clock = izaehler_uhr.q[14]; 184 izaehler_sek_z.clock =!izaehler_sek_e.q[3]; 185 izaehler_min_e.clock =!izaehler_sek_z.q[2]; 186 izaehler_min_z.clock =!izaehler_min_e.q[3]; 187 izaehler_std_e.clock =!izaehler_min_z.q[2]; 188 izaehler_std_z.clock =!izaehler_std_e.q[3]; % Schieberegister (Takt) % 192 isr_dcf.clock = clock_dcf; % Zustandsmaschine % 196 izm_dcf.clk = clock_dcf; 197 izm_dcf.reset =!reset; CASE izm_dcf IS 200 WHEN z0 => % Ausgangszustand (izaehler_dcf loeschen) % 201 izaehler_dcf.aclr = VCC; 202 IF iff_dcf_in.q THEN 203 izm_dcf = z1; 204 END IF; WHEN z1 => % izaehler_dcf freigeben (=starten) % Seite 31

32 208 izaehler_dcf.cnt_en = VCC; 209 izaehler_dcf.clk_en = VCC; 210 IF!iFF_DCF_In.q THEN 211 izm_dcf = z2; 212 ELSIF (izaehler_dcf.q[] >= KONSTDCFTIMEOUT) THEN 213 izm_dcf = z7; 214 END IF; WHEN z2 => 218 IF ((izaehler_dcf.q[] >= KONSTDCFLMIN) & 219 (izaehler_dcf.q[] <= KONSTDCFLMAX)) THEN % LOW % izm_dcf = z3; ELSIF ((izaehler_dcf.q[] >= KONSTDCFHMIN) & 224 (izaehler_dcf.q[] <= KONSTDCFHMAX)) THEN % HIGH % izm_dcf = z4; ELSIF ((izaehler_dcf.q[] >= KONSTDCFMINMIN) & 229 (izaehler_dcf.q[] <= KONSTDCFMINMAX)) THEN % Min-Wechsel% IF iff_dcf_fehler.q THEN 232 izm_dcf = z6; 233 ELSE 234 izm_dcf = z5; 235 END IF; 236 ELSE 237 izm_dcf = z7; % Fehler % 238 END IF; WHEN z3 => % LOW dem Schieberegister hinzufuegen % 242 isr_dcf.enable = VCC; iff_dcf_lo.d = VCC; % iff_dcf_lo setzen % 245 iff_dcf_lo.ena = VCC; 246 iff_dcf_hi.ena = VCC; % iff_dcf_hi loeschen % 247 iff_dcf_bitfehler.ena = VCC; % iff_bitfehler loeschen % izm_dcf = z0; % Naechster Zustand % WHEN z4 => % High dem Schieberegister hinzufuegen % 253 isr_dcf.shiftin = VCC; 254 isr_dcf.enable = VCC; iff_dcf_hi.d = VCC; % iff_dcf_hi setzen % 257 iff_dcf_hi.ena = VCC; 258 iff_dcf_lo.ena = VCC; % iff_dcf_lo loeschen % 259 iff_dcf_bitfehler.ena = VCC; % iff_bitfehler loeschen % izm_dcf = z0; % Naechster Zustand % WHEN z5 => % Neue Minute und gueltiges Telegramm % 265 iff_dcf_sync.d = VCC; 266 iff_dcf_sync.ena = VCC; % iff_dcf_sync setzen % izaehler_uhr.aclr = VCC; % izaehler_uhr loeschen % 269 izaehler_sek_e.aclr = VCC; % izaehler_sek_e loeschen % 270 izaehler_sek_z.aclr = VCC; % izaehler_sek_z loeschen % 271 izaehler_min_e.aload = VCC; % izaehler_min_e laden % 272 izaehler_min_z.aload = VCC; % izaehler_min_z laden % 273 izaehler_std_e.aload = VCC; % izaehler_std_e laden % 274 izaehler_std_z.aload = VCC; % izaehler_std_z laden % izm_dcf = z0; % Naechster Zustand % 277 Seite 32

33 WHEN z6 => % iff_dcf_fehler loeschen % 280 iff_dcf_fehler.ena = VCC; 281 izm_dcf = z0; % Naechster Zustand % WHEN z7 => 285 iff_dcf_fehler.d = VCC; % iff_dcf_fehler setzen % 286 iff_dcf_fehler.ena = VCC; iff_dcf_bitfehler.d = VCC;% iff_dcf_bitfehler setzen % 289 iff_dcf_bitfehler.ena = VCC; 290 iff_dcf_lo.ena = VCC; % iff_dcf_lo loeschen % 291 iff_dcf_hi.ena = VCC; % iff_dcf_hi loeschen % izm_dcf = z0; % Naechster Zustand % 294 END CASE; % Schieberegister - Zaehler fuer Uhrzeit und Datum % 298 izaehler_min_e.data[0] = isr_dcf.q[36]; 299 izaehler_min_e.data[1] = isr_dcf.q[35]; 300 izaehler_min_e.data[2] = isr_dcf.q[34]; 301 izaehler_min_e.data[3] = isr_dcf.q[33]; 302 izaehler_min_z.data[0] = isr_dcf.q[32]; 303 izaehler_min_z.data[1] = isr_dcf.q[31]; 304 izaehler_min_z.data[2] = isr_dcf.q[30]; izaehler_std_e.data[0] = isr_dcf.q[28]; 307 izaehler_std_e.data[1] = isr_dcf.q[27]; 308 izaehler_std_e.data[2] = isr_dcf.q[26]; 309 izaehler_std_e.data[3] = isr_dcf.q[25]; 310 izaehler_std_z.data[0] = isr_dcf.q[24]; 311 izaehler_std_z.data[1] = isr_dcf.q[23]; 312 izaehler_std_z.aclr = izaehler_std_z.q[1] & izaehler_std_e.q[2]; 313 izaehler_std_e.aclr = izaehler_std_z.q[1] & izaehler_std_e.q[2]; % Zaehler Uhr - FF Sync % 317 izaehler_uhr.cnt_en = iff_dcf_sync.q; 318 izaehler_uhr.clk_en = iff_dcf_sync.q; % Ausgaenge % 322 outdcf_fehler = iff_dcf_fehler.q; 323 outsek_takt = izaehler_uhr.q[14]; outdcf_sync = iff_dcf_sync.q; outdcf_lo = iff_dcf_lo.q; 328 outdcf_hi = iff_dcf_hi.q; 329 outdcf_bitfehler = iff_dcf_bitfehler.q; outsek_e[] = izaehler_sek_e.q[]; 332 outsek_z[] = izaehler_sek_z.q[]; outmin_e[] = izaehler_min_e.q[]; 335 outmin_z[] = izaehler_min_z.q[]; outstd_e[] = izaehler_std_e.q[]; 338 outstd_z[] = izaehler_std_z.q[]; outanzeige_en = iff_dcf_sync.q; 341 END; Seite 33

34 Anmerkungen und Erläuterungen zum Design-File: Das Design-File sieht wie ein Listing eines z.b. C-Programms aus. Es ist aber zu beachten, dass es sich hier keinesfalls um ein Programm handelt, welches sequentiell (also Schritt-für-Schritt) abgearbeitet wird. Hier handelt es sich um die Beschreibung einer Schaltung! Die Zeilen 1 bis 8 sind Kommentare und dienen der Kurzbeschreibung der Software, den Namen des Entwicklers und einige zusätzliche Informationen. (Anmerkung: Kommentare befinden sich in AHDL zwischen zwei %-Zeichen, z.b. % Kommentar %) In den Zeilen 11 und 12 werden die von ALTERA zur Verfügung gestellten Bibliotheken eingebunden. Hier für die verwendeten Zähler (izaehlerxxx) und für das Schieberegister (isr_dcf) Im Design werden mehrere Konstanten verwendet. (Hier u.a. zur Unterscheidung zwischen den Low- und High-Bits, einem Minutenwechsel, usw.) Konstanten werden in AHDL mit dem SchlüsselwortCONSTANT definiert. In den Zeilen 16 bis 23 werden alle in diesem Design verwendeten Konstanten definiert. In den Zeilen 29 bis 52 werden alle Ein- und Ausgänge definiert. Hier lautet die AHDL-Syntax: Name des Ein- oder Ausgangs : Typ; (Als Typ kann verwendet werden: INPUT (für Eingang), OUTPUT (für Ausgang) oder BIDIR (für bidirektional). Die Zeilen 59 bis 65 definieren die verwendeten FlipFlops. Hier lautet die AHDL- Syntax: Name des FlipFlops : FlipFlop-Typ; (Als FlipFlop-Typen stehen z.b, DFF (D-FlipFlop), DFFE (D-FlipFlop mit Freigabe), SRFF (S-R-FlipFlop), SRFFE (S-R-FlipFlop mit Freigabe), JKFF (J-K-FlipFlop), JKFFE (J-K-FlipFlop mit Freigabe) usw. zur Verfügung) Die Zeilen 68 bis 125 definieren die verwendeten Zähler. Hier lautet die AHDL- Syntax: Name des Zählers : lpm_counter WITH ( PARAMETERLISTE ); (Die Parameterliste beinhaltet zumindest die Anzahl der Bits(LPM_WIDTH). Weiters können hier Parameter wie die Zählrichtung (LPM_DIRECTION), die obere Zählgrenze (LPM_MODULUS), usw. definiert werden. Die obere Zählgrenze ist bei dieser Anwendung ganz besonders wichtig. Denn der Zähler izaehler_sek_z soll beispielsweise nur von 0 bis 5 zählen. Daher ist für diesen Parameter der Wert 6 notwendig. Der folgende Programmausschnitt (Zeilen 90 bis 95) zeigt die Definition für diesen Zähler. 90 izaehler_sek_z : lpm_counter WITH 91 ( 92 LPM_WIDTH = 3, 93 LPM_DIRECTION = "UP", 94 LPM_MODULUS = 6 95 ); Die Zeilen 129 bis 132 definieren das verwendete Schieberegister (isr_dcf). Hier lautet die AHDL-Syntax: Name des Schieberegisters : lpm_shiftreg WITH ( PARAMETERLISTE ); (Die Parameterliste beinhaltet zumindest die Anzahl der Bits (LPM_WIDTH). Weiters können hier Parameter wie z.b. die Schieberichtung(LPM_DIRECTION), usw. definiert werden. Die Zeilen 136 bis 147 definieren die verwendete Zustandsmaschine (izm_dcf). Hier lautet die AHDL-Syntax: Name der Zustandsmaschine :MACHINE OF BITS (Bitanzahl) WITH STATES (Z0 = 0, Z1 = 1, Z2 = 2 usw. ); Nun beginnt ab Zeile 151 die Beschreibung des Designs vom Bild 12a. Seite 34

35 Die Zeilen 153 bis156 beschreiben die Eingänge des FlipFlops zur Synchronisierung des DCF-Eingangs. Dieses FlipFlop hat die Bezeichnung iff_dcf_in. Die verschiedenen Eingänge eines Objektes werden folgendermaßen angesprochen: Objekt.Eingang (z.b. Dateneingang des FlipFlops zur Synchronisierung: iff_dcf_in.d oder Takteingang des Sekundentakt-ZählersiZAEHLER_Uhr.clock) Zurück zum FlipFlop zur Synchronisierung des DCF-Eingangs. Gemäß dem Design (Bild 5.12a) ist der Takteingang dieses Flipflops mit dem Systemtakt verbunden, daher lautet die AHDL-Anweisung: iff_dcf_in.clk = clock_dcf; (Zeile 153), Der Dateneingang ist mit dem DCF-Eingang verbunden, die AHDL-Anweisung lautet daher: iff_dcf_in.d = indcf_in; (Zeile 154) Sowohl der Set- als auch der Reset-Eingang dieses FlipFlops sind mit VCC verbunden. Die AHDL-Anweisungen lauten daher: iff_dcf_in.prn = VCC; (für Set-Eingang; Zeile 155) iff_dcf_in.clrn = VCC; (für Reset-Eingang; Zeile 156) Die Zeilen 159 bis 177 beschreiben die Eingänge der restlichen FlipFlops, mit Ausnahme der Dateneingänge. Die Dateneingänge stammen von der Zustandsmaschine (izm_dcf) und werden an anderer Stelle beschrieben. Der System-Reset stammt aus der Hardwarebeschaltung des CPLDs und ist lowaktiv (siehe auch Abschnitt 3). Lowaktiv sind auch die Set und Reset-Eingänge der FlipFlops, sodass diese direkt mit dem System-Reset verbunden werden können. Die Zeilen 180 bis 188 beschreiben die Verdrahtung der Takteingänge für die Zähler. Die Zähler izaehler_dcf und izaehler_uhr sind mit dem Systemtakt (clock_dcf) verbunden. In AHDL lautet diese Verbindungen daher izaehler_dcf.clock = clock_dcf; (Zeile 180) izaehler_uhr.clock = clock_dcf; (Zeile 181) Die weiteren Zähler (für die Uhrzeit) sind hintereinander geschaltet, d.h. der Takt eines Zählers stammt von einem Ausgang des vorhergehenden Zählers. (siehe Bild 5.12a) Weiters muss dieser Ausgang negiert werden. Für die Negierung wird in AHDL ein! verwendet. Somit lautet die AHDL-Anweisung für den Takteingang des Zählers izaehler_sek_z: izaehler_sek_z.clock =!izaehler_sek_e.q[3]; (Zeile 184) Anmerkung: Der Zähler izaehler_sek_e ist ein 4-bit-Zähler. Das heißt er besitzt daher 4 Ausgänge. Die eckige Klammer gibt an welche der 4 Ausgänge benutzt wird, wobei beim Zählen mit 0 begonnen wird. [3] bedeutet daher, dass der vierte Ausgang benutzt wird. Seite 35