Direkt zu ...
Die Portview Platine, ist ein kleiner Allrounder auf der ich schon mehrere kleine Anwendungen programmiert habe. Ursprünglich als kleiner Helfer zum debuggen, habe ich noch ein Digitales Voltmeter DVM und einen universellen Count Down Timer programmiert. Da man je nach Anwendung einiges im Quellcode einstellen kann, ist bei manchen Anwendungen keine brennfertige Hex-Datei dabei. Diese kann man aber leicht selbst erzeugen indem man sich das (kostenlose) AVR-Studio (bei mir noch 4.18) bei Atmel herunterlädt, ein neues (Assembler) Projekt erstellt und den Quellcode (einfach Copy & Paste) in das Editorfenster einfügt.
Nach build befindet sich dann die Hex-Datei im Projekt Ordner.
Dieses kleine Display habe ich mir gebaut, um während des programmieren (Debuggen) mal schnell eine Variable an einem freien AVR-Port auszugeben. Diese wird dann im gewünschten Zahlenformat angezeigt. Deshalb habe ich die Pinbelegung passend zum STK500 gemacht, welches das Modul dann auch gleich mit Spannung versorgen kann. Selbstverständlich kann es auch an Breadbords angeschlossen werden, wenn man sich eine passendes Kabel anfertigt.
Sogar für eigene Projekte währe es als Display denkbar, wenn Werte von 0..255 ausreichen.
Über eine 10 polige Pfostenleiste kann das Display mit einem freien Port des Mikrocontrollers verbunden werden und zeigt den binären Wert, abhängig von der Jumperstellung als Dezimal, Hexadezimal oder Binärzahl an. Auch ein automatischer Wechsel der Zahlenformate (alle 2 Sekunden) ist möglich.
Das Modul könnte auch als "8-Bit Binär zu Dezimal (Hex./Bin.) Siebensegmentdecoder" bezeichnet werden.
Schaltplan
Wie man sieht, teilt sich der 8-Bit Eingang PortC und PortD.
Das hat folgenden Grund: Ich wollte unbedingt die AD-Wandlerpins frei
haben um die Platine auch für andere Projekte nutzen zu können.
Mit passender Firmware währen z.B. ein Thermometer, Voltmeter usw.
denkbar. Mit der Portview Firmware, könnte man es auch als
intelligentes Display verwenden um Zahlen bis 255 (ein Byte eben)
darzustellen ohne selbst zu multiplexen oder die Zahlen umwandeln zu
müssen.
Die drei 13mm Anzeigen mit gemeinsamer Anode, werden im
Multiplexverfahren über die 3 PNP Transistoren (BC857/SMD)
angesteuert. Die einzelnen Segmente liegen durchverbunden an
PortB. Die Segmente sind aus Layouttechnischen Gründen
gespiegelt angeschlossen, dies hat trotz der verwendeten SMD-Bauteilen
auf der Unterseite, eine einseitige Platine ermöglicht . Es kann sowohl
der AT-Mega8 als auch der AT-Mega48 verwendet werden. Diese sind
Pinkompatibel. Es müssen lediglich im Quellcode, 3 Zeilen geändert
werden (auskommentieren). Wie man sieht habe ich bei meiner
Platine wieder mit Löstoplaminat gearbeitet um dies auch bei SMDs zu
testen.
Layout
Oberseite
Lötseite
Bedingt durch die einseitige Ausführung der Platine, müssen ein paar Drahtbrücken in Kauf genommen werden. Selbstätzer die es sich zutrauen, könnten diese noch reduzieren, wenn sie die VCC Leiterbahn durch R3 und R2 hindurch führen würden . Ich habe beim Bestücken mit der Lötseite angefangen. Dann die Drahtbrücken. Für die Anzeigen habe ich mir eine 40-polige IC-Fassung passend gekürzt um so die Wahl auf mehrere Anzeigen auszuweiten. Zum Schluss die Pinheader bestücken.
Die freien Lötpads an den 3 Anzeigen sind die Dezimalpunkte des Displays. Sie sind für evtl. Erweiterungen gedacht.
Stückliste
R1 - R3 | 1K | Widerstand 0805 SMD |
R5 - R11 | 120 Ohm | Widerstand 0805 SMD |
R12 | 10k | Widerstand 0805 SMD |
C1, C2 | 100nF | Keramik Kondensator 0805 SMD |
T1 - T3 | BC557B | Transistor SMD |
D1 - D3 | SA52-11GWA | Kingbright 7 Segmentanzeige gem. Anode (o.Ä.) |
IC1 | Mega8 oder Mega48 | Mikrocontroller Bauform TQFP |
Sonstiges: Pinheader im 2.54
Raster, Jumper, evtl. Fassung für die Anzeigen |
Bedienung & Download
Die internen Pullupwiderstände des AVRs sind aktiviert. Wird
also das Modul mit +5V verbunden, zeigt das Display bei offenem Eingang
255, hFF oder bII an, je nach Jumperstellung. Sind keine Jumper
gesteckt wird dezimal angezeigt. Wird Jumper 1 gebrückt, wird in
hexadezimal angezeigt. Das ist auch daran zu erkennen, das ein
vorgestelltes "h" auf dem Display erscheint.
Jumper2 aktiviert binär. Das sieht zunächst etwas kryptisch aus, da ja
keine 8 Anzeigen verbaut sind. Hier gibt kleines "b" in D1 zu
erkennen, das wir uns im Binärmodus befinden. Bei den nächsten beiden
Anzeigen müssen wir in Gedanken einen waagerechten Strich in der mitte
der Anzeige ziehen (Segment g). Oberhalb dieser gedachten Mittellinie
befindet sich das höherwertige Nibble unterhalb das niederwertige. Für
jedes gesetzte Bit ist das jeweilige senkrechte Segment von links nach
rechts zuständig. Das höhrt sich komplizierter an, als es ist. In der
Praxis hat man das ablesen der Binärzahl schnell raus.
Beispiel: Im Foto unten wird die Binärzahl 0b10110100 angezeigt.
Wenn beide Jumper gesteckt sind, wechselt die Zahlendarstellung im 2 Sekundentakt.
Im Clip oben, sitzt ein Tiny2313 im STK500 mit folgenden kleinen Testprogramm welches PortB hochzählt.
ldi r16, LOW(RAMEND)
out SPL, r16
ldi r16,$ff
out ddrb,r16
clr r17
out portb,r17
lop:ldi r20,40
rcall wait
inc r17
out portb,r17
rjmp lop
wait:
dec r18
brne wait
dec r19
brne wait
dec r20
brne wait
ret
Eagle Dateien,ASM und Hex File
Den AVR mit dem internen RC-Ozillator auf 8 MHz einstellen.
Viel Spass beim Basteln, Jürgen
Als
zusätzliche Hardware reicht schon ein Spannungsteiler und schon wird
aus dem Portview Modul ein Digitales Voltmeter (DVM). Die verwendeten
Widerstände müssen noch nicht einmal eng toleriert sein, in meinem
Probeaufbau habe ich absichtlich normale Kohleschichtwiderstände mit 5%
Toleranz benutzt.
Das DVM könnte sehr schön in einem selbstgebauten LM317 Netzteil Platz
finden, nur muss man sich darüber im klaren sein, das das DVM eine
eigene +5 Volt Spannungsversorgung benötigt. Da man die 5
Volt
zusätzlich nach aussen führen kann, sehe ich das nicht
unbedingt
als Nachteil.
Das Modul wird nicht wie üblich mit genauen Messwiderständen oder
Trimmpotis abgeglichen sondern über die Software. Dazu brauchen wir
eine einstellbare Spannungsquelle und ein brauchbares Multimeter, je
genauer, desto besser. Die Widerstände sind wie gesagt nicht kritisch
und können der Bastelkiste entnommen werden. Falls nicht schon
geschehen müssen wir AVR-Studio (bei mir 4.18) auf den
Rechner installieren, welches man sich kostenlos bei Atmel
herunterladen kann.
Anschluss
Auf der Skizze oben sieht man, wie der Spannungsteiler angeschlossen wird. Die Werte von R1 und R2 sind nur ein Beispiel und können den eigenen Bedürfnissen angepasst werden. Ziel bei diesem Beispiel ist ein DVM mit >30.0 Volt. Ob die Obergrenze später bei 32.8 oder 34.2 Volt liegt, ist dabei unerheblich. Die Berechnung des Spannungsteilers kann man über den Daumen abschätzen. Wer es genau wissen will kann hier und hier alles nachlesen. Im Beispiel oben, addieren wir R1 und R2 und errechnen einen Gesamtwiderstand von ca. 12k. Da R2 gut 5 mal in R1 passt, fällt an R1 auch 5 mal soviel Spannung ab. Bei 30Volt am Eingang liegen also am Knotenpunkt von R1/R2 ca. (30-25V) 5 Volt an (eher weniger da der Wert von R2 ja nicht 2k sondern nur 1,8k beträgt). Anhand des verwendeten Spannungsteiler stellt man vref ein. Im Beispiel oben habe ich 5V gewählt. Würde man 2,56 Volt für vref programmieren könnte man mit dem Spannungsteiler oben Spannungen von ca. 0...15 Volt messen.
Die Software...
...ist für den AT-Mega8 geschrieben. Dieser muss auch auf dem Portview Modul verbaut sein. Assemblerkundige können den Code natürlich auch an den Mega48/88 anpassen und diesen verwenden.
;---------------------------------------------------------------------------------------------------
;Konstanten für die Berechnung der Anzeige bei 1023 am ADC Ausgang
;für die 4 möglichen Jumperstellungen
;---------------------------------------------------------------------------------------------------
;Endausschlag
;------------
;Durch ändern der Formel z.B. "faktor1 =123*$10000/1024", zeigt das Display bei 5V
;am ADC Eingang 12.3 V an.
;(DP der Anzeige vor der letzten Stelle, Jumper offen)
;Ein passender Spannungsteiler muss vorgeschaltet werden
.equ faktor1 = 322*$10000/1024 ;Jumper offen
.equ faktor2 = 200*$10000/1024 ;200= Anzeige bei +5V am Analogeingang. Spannungsteiler 4:1
.equ faktor3 = 300*$10000/1024 ;300, Spannungsteiler 6:1
.equ faktor4 = 400*$10000/1024 ;400, Spannungsteiler 8:1
;Danach wird wieder durch $10000 geteilt (die unteren 16Bit der Multiplikation verworfen)
;---------------------------------------------------------------------------------------------------
;Nullabgleich
;------------
.equ offset = 3 ;Wird zum ausgelesenen ADC-Wert addiert. Der Offset wird so gewählt, das
;wenn der ADC-Eingang mit GND verbunden wird, die Anzeige gerade noch 00,0 anzeigt.
;Dadurch kann sich der Endausschlag um 0,1V nach oben verschieben, sodass man diesen nachbessern muss.
;---------------------------------------------------------------------------------------------------
;Referenzspannung
;----------------
;Bei z.B. vref=5V müssen am Spannungsteiler 5V Abfallen damit der Endausschlag angezeigt wird.
;Einen der beiden Werte Auskommentieren.
;.equ vref = 1<<REFS0|1<<REFS1 ;2,56V intern
.equ vref = 1<<REFS0 ;5V intern
;---------------------------------------------------------------------------------------------------
Oben sieht man den Code der für den Abgleich des DVM
ausschlaggebend ist. Die Einträge faktor2..4 sind für zukünftige
Erweiterungen, die Jumper müssen offen bleiben.
Es sind nicht unbedingt ASM Kenntnisse erforderlich um den Abgleich
durchzuführen. Allerdings sollte man sich ein wenig mit dem AVR-Studio
vertraut machen. Dazu ein neues Projekt erstellen, die ASM
Datei mit Copy/Paste in das Textfenster kopieren und um die brennbare
Hex Datei zu erhalten, assemblieren (Build oder F7 drücken).
Folgendes sollte man über den internen AD-Wandler des Mega8 wissen.
Wird eine Spannung an einen ADC-Eingang gelegt, liefert der AD-Wandler einen Digitalen Wert der 10 Bit breit ist. Dezimal ist das ein Wert zwischen 0...1023. Die Spannung am Eingang darf zwischen 0...5 Volt liegen, wenn die interne Referenzspannung (vref) auf 5 Volt eingestellt ist oder 0...2,56 Volt wenn vref auf intern 2,56 programmiert wird. Der digitale Wert wird also abhängig von vref die besagten 1023 liefern wenn (bei vref=5Volt) 5 Volt am ADC-Eingang anliegen oder eben schon (bei vref=2,56) bei 2,56 Volt.
Oft sieht man in MC-Programmen, das der Spannungsteiler bei den Berechnungen der Anzeige mit einbezogen wird. Dann sind natürlich möglichst Präzise Messwiderstände erforderlich. Ich gehe hier einen anderen Weg. Der Spannungsteiler oder das Verhältnis selbst, taucht in meinem Programm an keiner Stelle auf.
Es wird lediglich ein dezimaler Wert, abhängig vom 10-Bitwert des AD-Wandlers errechnet und angezeigt. Der dezimale Wert darf maximal 999 (begrenzt durch die 3 stellige Anzeige) betragen und wird am Anfang des Programms als Konstante definiert.
Dadurch fällt bei der Genauigkeit des DVM, auch die doch recht große Range von Vref nicht mehr ins Gewicht, die im Datenblatt des Mega8, für 2,56V von 2,3V - 2,7V betragen darf.
Abgleich
Zuerst die ASM-Datei assemblieren und in den Mega8 brennen (ausser vref, ruhig die Werte mal so lassen). Jetzt das Modul mit +5 Volt Spannung versorgen und am Eingang des Spannungsteilers die einstellbare Spannungsquelle anschliessen. Diese vorher auf Minimum stellen. Das Multimeter an den Knotenpunkt R1/R2 anschliessen und den Messbereich auf Gleichspannung stellen. Wie schon erwähnt müssen die Jumper offen bleiben.
Endausschlag
Bei gleichzeitiger Beobachtung von Multimeter und DVM, die Spannung langsam erhöhen. Wenn die Anzeige des Multimeters, in die Nähe der programmierten Referenzspannung kommt vorsichtig weiter erhöhen bis das DVM "HH.H" anzeigt. Jetzt kommen die besagten 1023 vom Wandler. Vorsichtig die Spannung zurückdrehen bis wieder Ziffern auf dem DVM erscheinen. Wir suchen den Punkt an dem "HH.H" gerade noch angezeigt wird. Haben wir diesen gefunden, das Multimeter auf den Eingang des Spannungsteilers Umklemmen und die Spannung vom Multimeter ablesen. Diesen Wert *10 (bei z.B. 32.3 Volt 323) in das ASM-Programm bei Faktor 1 eintragen, neu assemblieren und brennen.
Nullabgleich
Dazu die Spannungsquelle abklemmen. Der ADC-Eingang sollte entweder direkt, oder über R2 des Spannungsteilers mit GND verbunden sein, ansonsten erscheinen willkürlich Zahlen auf den 7Segmentanzeigen. Ist die Anzeige schon auf "00.0" Schrittweise die Konstante "offset" um 1 erhöhen bis die Anzeige "00.1" anzeigt. Nun den offset wieder um 1 vermindern. Der Nullpunkt ist also eingestellt, wenn offset den maximalen Wert erreicht hat bei dem die Anzeige gerade noch "00.0" anzeigt. Nun kann das Modul wieder an die Spannungsquelle und Multimeter angeschlossen werden um den kompletten Spannungsbereich zu kontrollieren. Durch den Nullabgleich, kann sich der Maximalwert des DVM nochmals um 0,1 V verändern sodass man hier nochmals nachbessern muss.
Tipps:
- Will man Spannungen unter 10V messen, kann man den Dezimalpunkt um eine Stelle nach links verschieben und somit die Auflösung erhöhen. Dadurch währen Spannungen von "0.00" bis "9.99" messbar.
- Kippt die Anzeige bei 0,1 Volt ungünstig (z.B. bei 4,95 Multimeter auf "04.9" auf dem DVM) , kann es von Vorteil sein den Offset um 1 zu erhöhen (vermindern). Die Anzeige beginnt dann evtl. bei "00.1" , das fällt aber nur ins Gewicht, wenn das Netzteil in dem das DVM betrieben werden soll, bei 0V beginnt.
- Da Vref abhängig von der Versorgungsspannung des DVM ist, sollte der Abgleich mit dem Netzteil erfolgen, mit dem es später betrieben werden soll.
- Man könnte auch einen Sensor anschliessen dessen Ausgangsspannung in einem Spannungsteiler linear ansteigt. Oder Z.B. einen Drucksensor wie den MPX5700, welchen ich in meiner Kompressorsteuerung verwendet habe. Allerdings währen hier Programmierkentnisse nötig da z.B bei einem Temperatursensor der Offset negativ währe und dies dann Ausgewertet werden müsste.
Nachwort:
Wie man sieht, ist die Bauanleitung für das DVM nicht (wie viele meiner anderen Projekte) "Plug & Play". Vielleicht regt es den einen oder anderen dazu an, sich in das Interessante Thema der AVR-Programmierung einzulesen.
Viel Spass beim tüfteln, Jürgen
Download
Universaltimer
Der
Timer kann Minuten, Sekunden oder sogar 1/10 und 1/100
Sekunden zählen. So kann man durch ändern von ein paar Parameter im
ASM-Quellcode die Range einstellen über die der Timer zählt. Das sind
z.B. 9:59 Minuten, 99.9 Sekunden, 9,99 Sekunden, 9:59 Stunden und mehr.
Der Timer ist also nicht nur zum belichten von Platinen geeignet, man
könnte ihn z.B. auch zum Kuchen backen oder fürs Fotolabor benutzen.
Die Count Down Zeit ist einstellbar über einen Drehimpulsgeber ODER 3 Tasten
(<Up>,<Down>,<OK>).
Bei verwendung des Drehgebers, können die
beiden <Up>,<Down> Taster
weggelassen werden. Die Software wertet jedenfalls beides aus.
Im Quellcode befindet sich eine Tabelle, wo öfters benötigte
Startzeiten als Preset abgelegt werden können. Diese können
dann später mit einem Doppelclick auf <OK> aufgerufen
werden. Ein langer Tastendruck aktiviert die Schnelleingabe. Hierbei
werden die beiden niederwertigen Anzeigen ausgeblendet und nur die (bei
M:SS Einstellung) Minuten eingestellt. Ist die gewünschte Zeit
eingestellt, startet ein Tastendruck auf <OK> den Count
Down. Währed der Count Down läuft, ist der Schaltausgang auf High
Potential an den man über einen Treibertransistor ein Relais schalten
kann. Am Ende des Count down wird dann der Summer geschaltet (Dauer im
Quellcode einstellbar). Wie auch bei meinem UV-Timer
habe ich am Ende ein Paar Displayspielereien angefügt. Diese können
durch setzen eines Flags im Quellcode auch deaktiviert werden.
Videoclip
Einstellung
Am Anfang des Assembler Listing kann man festlegen wie der Timer den Count Down herunter zählen soll. Ein Timerinterrupt der alle 1 mS aufgerufen wird, zählt dabei eine 16-Bit Variable herunter die zuvor mit dem Countms Wert geladen wurde. Wird also Countms=1000 definiert wird beim Count Down Sekundenweise gezählt.
Auszug aus dem ASM-Programm
;------------------------
#define mega48 ;Einen der beiden AVRs auskommentieren
;#define mega8
;---------------------------------------------------------------------------------------------------
;Der CountmS Wert bestimmt wieviele Millisek. gezählt werden, bis eine Zeiteinheit um ist.
;Beispiele: 1000 = 1 Sekunde Auflösung = max. "9.59" Min. oder "999" Sekunden
;60000 = 1 Minute Auflösung = max. "9.59" Std.
;100 = 0,1 Sek. Auflösung = max. "99.9" Sekunden | 10 = 0,01 Sek. Auflösung = max. "9.99" ;Sekunden
.equ countms = 1000 ;Zeit in Millisekunden.
;---------------------------------------------------------------------------------------------------
.equ overf = 60 ;60 bei 9:59 Minuten oder Stunden. 100 bei "99.9" oder "999" Sek
.equ korrektur = 0 ;Macht die Uhr Wert*1mS pro Sekunde langsamer, negativ=schneller
.equ premin = 0 ;Preset Minuten. Bei Power on
.equ presek = 0 ;Preset Sekunden. Dito
.equ buzztime = 5 ;Summer: Dauer in 1/2 Sekunden (*512mS)
.equ rep_kurz = 25 ;Tastenwiederholung, Verzögerung *2 Millisekunden
.set encoder = 0 ;Geschwindigkeit Drehimpulsgeber 0=1/4=(langsam),1=1/2(mittel),2=(schnell)
.set scroll = 1 ;Spielerei bei Count Down Ende. 0/1 = Aus/Ein
;*******************************************************************************************************
Der overf
Wert bestimmt ob der Timer bei einem Counterstand von z.B.
"1:00" auf "0:59" oder "099" zählt. Möchte man nur Sekunden zählen
definiert man overf=100
und lässt den Dezimalpunkt der Anzeige weg. Soll der Timer Minuten und
Sekunden zählen (M:SS) definiert man overf=60, der
Dezimalpunkt der 1. Anzeige wird dann verwendet.
Rep_kurz
ist für die Geschwindigkeit der Repeatfunktion der <Up>
und <Down> Taster zuständig. Drückt man z.B. den
<UP> Taster länger als eine halbe Sekunde zählt der Timer
bei rep_kurz=25
alle 50 mS die Zeit nach oben. Das ist 20 mal pro Sekunde .
Einfach mal mit dem Wert spielen und und das beste für sich
herausfinden.
Um auch Drehimpulsgeber aus der Bastelkiste nehmen zu können, kann man
die Geschwindigkeit so anpassen, das ein Rastpunkt später eine Änderung
von einer Sekunde entspricht. Bei meinem Exemplar kommen pro Rastpunkt
4 Flankenänderungen, deshalb habe ich encoder=0
eingestellt.
Premin und presek sind die
Startwerte beim einschalten des Timers. Buzztime ist die
Tondauer des Summers bei erreichen von 0:00.
Abgleich
Da das Portview Modul mit dem internen RC-Oszilator des AVRs
getaktet wird, ist ein Abgleich im Quellcode vorgesehen mit dem man
Zeitabweichungen entgegen wirken kann. Mir war es möglich bei einer
Einstellung von "M:SS" über die gesamte Zeit von 9:59 Minuten den Timer
Sekundengenau abzugleichen.
Den Korrekturwert ermittelt man am besten indem man den Timer eine
längere Zeit laufen lässt und die Zeit mit einer Uhr vergleicht. Die
Abweichung teilt man über den gemessenen Zeitraum auf und erhält so den
Korrekturwert.
Beispiel: Ein Korrekturwert von -1 macht den Timer über über 5 Minuten
(bei M:SS) um 0,3 Sekunden schneller.
(5 Min. = 300 Sek. | 300*1mS = 0,3 Sek.)
Presettabelle
;* Presettabelle.
;* --------------
;* Minuten, Sekunden. Beliebig erweiterbar.
;* Bei Doppelclick auf Start (oder Drehgeberbutton) können die
;* Zeiten mit Up/Down oder Drehgeber rechts/links ausgewählt werden.
;*************************************************************************************************
;Beispiel
PreTab: .db 0,50,\
0,35,\
2,20,\
3,15,\
5,00,\
0, 0
;*************************************************************************************************
In diese Tabelle kann man öfters benötigte Zeiten eintragen. Nur darauf achten das die beiden Nullen am Ende der Tabelle erhalten bleiben.
Anschluss
In der Mitte ein Vorschlag für ein 5V-Relais mit Treibertransistor und LED-Anzeige den man leicht auf einer Lochrasterplatine aufbauen kann.
In der Skizze oben, sieht man ein Beispiel mit einem Drehimpulsgeber. Sollen Taster (Bild rechts) verwendet werden, bleiben Pin4 und 5 (SV1) offen. An Pin 1 kommt anstatt des Drehgebertaster ein normaler Taster für <OK>, und an Pin 2 und 3 weitere Taster für <Up> und <Down>. Der Summer sollte ein 5V Gleichspannungstyp sein. Den passenden Dezimalpukt schaltet man mit einem 120 Ohm Widerstand gegen GND.
Download
Softwareupdate
14.10.2012
In dieser Version habe ich nach Wunsch von Manni und Leon noch 3 weitere Funktionen hinzugefügt.
- Die zuletzt gestartete Countdown-Zeit, wird im EEprom gespeichert und ist nach dem Neustart wieder auf dem Display.
- Das Countdown Ende, wird die letzten 5 Counts durch kurze Beeps angekündigt.
- In die Tabelle der Presetzeiten, wurden 0:30, 1:00 ... 9:00, 9:30 (alle 30 Sekunden) eingetragen. So können Voreinstellungen der Zeit schneller und bequemer vorgenommen werden
21.11.2012
Es wurden noch 2 kleine Bugs entfernt. (Geisterleuchten bei superhellen Anzeigen. Nach Power up, konnte es passieren, dass die letzte Zeit (EEprom-Wert) um 1 vermindert wurde).
Ich bedanke mich für die Hinweise, die ich per Email erhalten habe.
Viel Spass mit dem Timer, Jürgen
Wer selbst seine Platine ätzt, kennt das Problem. Die Lötpads
bei den Eagle Bauteilen sind meistens zu klein. Da ich es mir nicht
antun wil die kompletten Eagle Libs an meine Anforderungen anzupassen,
habe ich einfach mal grössere Lötpads auf die vorhandenen
Plaziert.
Ausserdem habe ich einen Vorwiderstand für den Dezimalpunkt auf der
Unterseite der Platine hinzugefügt.