Mikrocontroller.net - Benutzerbeiträge [de]

Entprellung

2022-01-25T11:15:29Z

172.26.38.125: /* Problembeschreibung */

== Problembeschreibung ==
Mechanische stromführende Komponenten wie [[Schalter]] und [[Taster/Knopf]] neigen beim Ein- und Ausschalten zum sogenannten '''Prellen''', d.h sie schalten schnell mehrfach aus und ein, was durch mechanische Vibrationen des Schaltkontaktes verursacht wird, sofern sie nicht mit aufwändigen mechanischen Maßnahmen dagegen geschützt sind. Besonders die [[Drehgeber]] sind aufgrund der Raststellungen und der Bewegung des Bedieners dafür empfindlich. Auch optoelektronische Bauelemente und chemische Kontaktschalter, sowie Flüssigkeitsschalter haben das Problem.

Vereinfacht dargestellt, sieht eine von einem prellenden Schalter oder Taster geschaltete Spannung wie folgt aus:
[[Bild:Entprellen.png]]

Es existieren also mehrere kurze Einschaltimpulse, welche bei Tastern als Mehrfachbefehl und bei Drehgebern als falsche Winkelbewegung interpretiert werden kann. Bei Schaltern wiederum, kommt es in der elektronischen Baugruppe zu mehreren Resets und Einschaltvorgängen, die unnötig Strom ziehen oder im schlechtesten Fall die Schaltung stressen oder beschädigen können. Wichtige Schalter und solche, die hohe Ströme führen sollen, werden dazu mit geeigneten Maßnahmen wie Redundanz, Stufenschaltkonzepten oder bei Gas- und Flüssigkeitschaltern durch elektrochemische Maßnahmen abgesichert. Bei einfachen Schaltern spart man sich dies jedoch.

Da es bei diesen einfachen, ungeschützten Schaltern keine sichere Möglichkeit gibt, diese Effekte zu vermeiden, muss das falsche Signal durch die Elektronik sinnvoll ausgewertet werden. Dafür gibt es verschiedene Ansätze:

== Hardwareentprellung ==

===Prellfreie Schalter===

Wie bereits angedeutet, hält die elektromechanische Industrie für Spezialanwendungen verschiedene Sonderkonstruktionen bereit, die saubere Schaltzustände nach Aussen generieren, indem sie entweder eine mechanische Dämpfung in Form eines selbsthemmenden Federmechanismus oder eine integrierte elektronische Signalverzögerung benutzen. Solche Systeme sind jedoch teuer und werden meist nur im Leistungsbereich eingesetzt. Zudem sind sie nicht 100% sicher und fallen alterungsbedingt aus. Wo immer es geht, werden daher weitere Maßnahmen getroffen, ein Prellen zu unterdrücken.

===Wechselschalter===

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

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

 

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

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

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

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

 

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

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

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

===Einfacher Taster===

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

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

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

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

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

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

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

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

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

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

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

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

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

== Softwareentprellung ==

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

Bei Verwendung des in den meisten Geräten ohnehin vorhandenen Mikrocontrollers z.B., kann man sich die zusätzliche Hardware sparen, da die Entprellung in Software praktisch genauso gut funktioniert. Dabei ist nur zu beachten, dass zusätzliche Rechenleistung und je nach Umsetzung auch einige Hardwareressourcen (z.B. Timer) benötigt werden. Dafür hat man aber den Vorteil, kurze Pulse, die offensichtlich keine Tastenbetätigung sein können sondern z. B. durch Einstreuungen hervorgerufen werden, einfach ausfiltern zu können.

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

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

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

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

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

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

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

return rw;
}
</syntaxhighlight>

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

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

=== Warteschleifen-Verfahren ===

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#include <avr/io.h>
#define F_CPU 9.6e6
#include <util/delay.h>

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

/*
Testapplication
*/
int main(void)
{
DDRB &= ~(1<<PB0);
PORTB |= 1<<PB0;
DDRB |= 1<<PB2;
DDRB &= ~(1<<PB1);
PORTB |= 1<<PB1;
DDRB |= 1<<PB3;
for(;;){
if( debounce( PINB, PB1 ) )
PORTB ^= 1<<PB2;
if( debounce( PINB, PB0 ) )
PORTB ^= 1<<PB3;
}
}

</syntaxhighlight>

Wenn das Makro für die gleiche Taste (Pin) an mehreren Stellen aufgerufen werden soll, muss eine Funktion angelegt werden, damit beide Aufrufe an die gleiche Zustandsvariable ''flag'' auswerten [http://www.mikrocontroller.net/topic/195914#1918727]:

<syntaxhighlight lang="c">
// Hilfsfunktion
uint8_t debounce_C1( void )
{
return debounce(PINC, PC1);
}

// Beispielanwendung
int main(void)
{
DDRB |= 1<<PB2;
DDRB |= 1<<PB3;
DDRC &= ~(1<<PC1);
PORTC |= 1<<PC1; // Pullup für Taster

for(;;){
if( debounce_C1() ) // nicht: debounce(PINC, PC1)
PORTB ^= 1<<PB2;
if( debounce_C1() ) // nicht: debounce(PINC, PC1)
PORTB ^= 1<<PB3;
}
}
</syntaxhighlight>

=== Timer-Verfahren (nach Peter Dannegger) ===

==== Grundroutine (AVR Assembler) ====

Siehe dazu: [http://www.mikrocontroller.net/forum/read-4-20435.html#new Forum]

Vorteile
* besonders kurzer Code
* schnell

Außerdem können 8 Tasten (aktiv low) gleichzeitig bearbeitet werden, es dürfen also
alle exakt zur selben Zeit gedrückt werden. Andere Routinen können z. B. nur eine Taste verarbeiten, d.h. die zuerst oder zuletzt gedrückte gewinnt, oder es kommt Unsinn heraus.

Die eigentliche Einlese- und Entprellroutine ist nur 8 Instruktionen
kurz. Der entprellte Tastenzustand ist im Register ''key_state''. Mit nur 2 weiteren Instruktionen wird dann der Wechsel von ''Taste offen'' zu
''Taste gedrückt'' erkannt und im Register ''key_press'' abgelegt. Im Beispielcode werden dann damit 8 LEDs ein- und ausgeschaltet. Jede Taste entspricht einem Bit in den Registern, d.h. die Verarbeitung erfolgt bitweise mit logischen Operationen. Zum Verständnis empfiehlt es sich daher, die Logikgleichungen mit Gattern für ein Bit = eine Taste aufzumalen. Die Register kann man sich als Flipflops denken, die mit der Entprellzeit als Takt arbeiten. D.h. man kann das auch so z. B. in einem GAL22V10 realisieren.

Als Kommentar sind neben den einzelnen Instruktionen alle 8 möglichen
Kombinationen der 3 Signale dargestellt.

Beispielcode für AVR (Assembler):

<syntaxhighlight lang="avrasm">
.nolist
.include "c:\avr\inc\1200def.inc"
.list
.def save_sreg = r0
.def iwr0 = r1
.def iwr1 = r2

.def key_old = r3
.def key_state = r4
.def key_press = r5

.def leds = r16
.def wr0 = r17

.equ key_port = pind
.equ led_port = portb

rjmp init
.org OVF0addr ;timer interrupt 24ms
in save_sreg, SREG
get8key: ;/old state iwr1 iwr0
mov iwr0, key_old ;00110011 10101010 00110011
in key_old, key_port ;11110000
eor iwr0, key_old ; 11000011
com key_old ;00001111
mov iwr1, key_state ; 10101010
or key_state, iwr0 ; 11101011
and iwr0, key_old ; 00000011
eor key_state, iwr0 ; 11101000
and iwr1, iwr0 ; 00000010
or key_press, iwr1 ;store key press detect
;
; insert other timer functions here
;
out SREG, save_sreg
reti
;-------------------------------------------------------------------------
init:
ldi wr0, 0xFF
out ddrb, wr0
ldi wr0, 1<<CS02 | 1<<CS00 ;divide by 1024 * 256
out TCCR0, wr0
ldi wr0, 1<<TOIE0 ;enable timer interrupt
out TIMSK, wr0

clr key_old
clr key_state
clr key_press
ldi leds, 0xFF
main: cli
eor leds, key_press ;toggle LEDs
clr key_press ;clear, if key press action done
sei
out led_port, leds
rjmp main
;-------------------------------------------------------------
</syntaxhighlight>

==== Komfortroutine (C für AVR) ====

Siehe dazu: [http://www.mikrocontroller.net/forum/read-4-310276.html Forum]

'''Anmerkung''' Wenn statt active-low (Ruhezustand High) active-high (Ruhezustand Low) verwendet wird muss eine Zeile geändert werden siehe:
[http://www.mikrocontroller.net/forum/read-4-310276.html gesamter Beitrag im Forum],
[http://www.mikrocontroller.net/topic/48465#606555 Stelle 1 im Beitrag], ([http://www.mikrocontroller.net/topic/48465#2306398 Stelle 2 im Beitrag] muss *nicht* geändert werden, da hier die Polarität gar keinen Einfluß hat).

'''Anmerkung 2''' Zur Initialisierung siehe [http://www.mikrocontroller.net/topic/48465#3572793 Forum]

Funktionsprinzip wie oben plus zusätzliche Features:
* Kann Tasten sparen durch unterschiedliche Aktionen bei kurzem oder langem Drücken
* Wiederholfunktion, z. B. für die Eingabe von Werten

Das Programm ist für avr-gcc/avr-libc geschrieben, kann aber mit ein paar Anpassungen auch mit anderen Compilern und Mikrocontrollern verwendet werden. Eine Portierung für den AT91SAM7 findet man [http://www.google.com/codesearch?q=show:ac2viP-2E2Y:pzkOO5QRsoc:RPICuprYy-A&sa=N&cd=1&ct=rc&cs_p=svn://mikrocontroller.net/mp3dec/trunk&cs_f=keys.c#a0 hier] (aus dem Projekt [[ARM MP3/AAC Player]]).
<syntaxhighlight lang="c">
/************************************************************************/
/* */
/* Debouncing 8 Keys */
/* Sampling 4 Times */
/* With Repeat Function */
/* */
/* Author: Peter Dannegger */
/* danni@specs.de */
/* */
/************************************************************************/

#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.h>

#ifndef F_CPU
#define F_CPU 1000000 // processor clock frequency
#warning kein F_CPU definiert
#endif

#define KEY_DDR DDRB
#define KEY_PORT PORTB
#define KEY_PIN PINB
#define KEY0 0
#define KEY1 1
#define KEY2 2
#define ALL_KEYS (1<<KEY0 | 1<<KEY1 | 1<<KEY2)

#define REPEAT_MASK (1<<KEY1 | 1<<KEY2) // repeat: key1, key2
#define REPEAT_START 50 // after 500ms
#define REPEAT_NEXT 20 // every 200ms

#define LED_DDR DDRA
#define LED_PORT PORTA
#define LED0 0
#define LED1 1
#define LED2 2

volatile uint8_t key_state; // debounced and inverted key state:
// bit = 1: key pressed
volatile uint8_t key_press; // key press detect

volatile uint8_t key_rpt; // key long press and repeat

ISR( TIMER0_OVF_vect ) // every 10ms
{
static uint8_t ct0 = 0xFF, ct1 = 0xFF, rpt;
uint8_t i;

TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5); // preload for 10ms

i = key_state ^ ~KEY_PIN; // key changed ?
ct0 = ~( ct0 & i ); // reset or count ct0
ct1 = ct0 ^ (ct1 & i); // reset or count ct1
i &= ct0 & ct1; // count until roll over ?
key_state ^= i; // then toggle debounced state
key_press |= key_state & i; // 0->1: key press detect

if( (key_state & REPEAT_MASK) == 0 ) // check repeat function
rpt = REPEAT_START; // start delay
if( --rpt == 0 ){
rpt = REPEAT_NEXT; // repeat delay
key_rpt |= key_state & REPEAT_MASK;
}
}

///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed. Each pressed key is reported
// only once
//
uint8_t get_key_press( uint8_t key_mask )
{
cli(); // read and clear atomic !
key_mask &= key_press; // read key(s)
key_press ^= key_mask; // clear key(s)
sei();
return key_mask;
}

///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed long enough such that the
// key repeat functionality kicks in. After a small setup delay
// the key is reported being pressed in subsequent calls
// to this function. This simulates the user repeatedly
// pressing and releasing the key.
//
uint8_t get_key_rpt( uint8_t key_mask )
{
cli(); // read and clear atomic !
key_mask &= key_rpt; // read key(s)
key_rpt ^= key_mask; // clear key(s)
sei();
return key_mask;
}

///////////////////////////////////////////////////////////////////
//
// check if a key is pressed right now
//
uint8_t get_key_state( uint8_t key_mask )

{
key_mask &= key_state;
return key_mask;
}

///////////////////////////////////////////////////////////////////
//
uint8_t get_key_short( uint8_t key_mask )
{
cli(); // read key state and key press atomic !
return get_key_press( ~key_state & key_mask );
}

///////////////////////////////////////////////////////////////////
//
uint8_t get_key_long( uint8_t key_mask )
{
return get_key_press( get_key_rpt( key_mask ));
}

int main( void )
{
LED_PORT = 0xFF;
LED_DDR = 0xFF;

// Configure debouncing routines
KEY_DDR &= ~ALL_KEYS; // configure key port for input
KEY_PORT |= ALL_KEYS; // and turn on pull up resistors

TCCR0 = (1<<CS02)|(1<<CS00); // divide by 1024
TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5); // preload for 10ms
TIMSK |= 1<<TOIE0; // enable timer interrupt

sei();

while(1){
if( get_key_short( 1<<KEY1 ))
LED_PORT ^= 1<<LED1;

if( get_key_long( 1<<KEY1 ))
LED_PORT ^= 1<<LED2;

// single press and repeat

if( get_key_press( 1<<KEY2 ) || get_key_rpt( 1<<KEY2 )){
uint8_t i = LED_PORT;

i = (i & 0x07) | ((i << 1) & 0xF0);
if( i < 0xF0 )
i |= 0x08;
LED_PORT = i;
}
}
}
</syntaxhighlight>

Das single-press-und-repeat-Beispiel geht nicht in jeder Beschaltung; folgendes Beispiel sollte universeller sein (einzelne LED an/aus):
<syntaxhighlight lang="c">
// single press and repeat
if( get_key_press( 1<<KEY2 ) || get_key_rpt( 1<<KEY2 ))
LED_PORT ^=0x08;
</syntaxhighlight>

Neuere Variante, die einer Taste folgende Funktionen erlaubt:
https://www.mikrocontroller.net/topic/48465?goto=1753367#1753367
<syntaxhighlight lang="c">
- get_key_press()
- get_key_rpt()
- get_key_press() mit get_key_rpt()
- get_key_short() mit get_key_long()
- get_key_short() mit get_key_long_r() und get_key_rpt_l()
</syntaxhighlight>
Erweiterung für die Erkennung von zwei gleichzeitig gedrückten Tasten:
https://www.mikrocontroller.net/topic/48465?goto=1753367#1753367
<syntaxhighlight lang="c">
- get_key_common()
</syntaxhighlight>

===== Funktionsweise =====
Der Code basiert auf 8 parallelen vertikalen Zählern, die über die Variablen ct0 und ct1 aufgebaut werden

[[Bild:VertCount.png|framed|center|'''8 vertikale Zähler in 2 8-Bit Variablen''']]

wobei jeweils ein Bit in ct0 mit dem gleichwertigen Bit in ct1 zusammengenommen einen 2-Bit-Zähler bildet.
Der Code der sich um die 8 Zähler kümmert, ist so geschrieben, daß er alle 8 Zähler gemeinsam parallel behandelt.

<syntaxhighlight lang="c">
i = key_state ^ ~KEY_PIN; // key changed ?
</syntaxhighlight>
i enthält an dieser Stelle für jede Taste, die sich im Vergleich mit dem vorhergehenden entprellten Zustand (keystate) verändert hat, ein 1 Bit.

<syntaxhighlight lang="c">
ct0 = ~( ct0 & i ); // reset or count ct0
ct1 = ct0 ^ (ct1 & i); // reset or count ct1
</syntaxhighlight>

Diese beiden Anweisungen erniedrigen den 2-Bit Zähler ct0/ct1 für jedes Bit um 1, welches in i gesetzt ist. Liegt an der entsprechenden Stelle in i ein 0 Bit vor (keine Änderung des Zustands), so wird der Zähler ct0/ct1 für dieses Bit auf 1 gesetzt.
Der Grundzustand des Zählers ist als ct0 == 1 und ct1 == 1 (Wert 3). Der Zähler zählt daher mit jedem ISR Aufruf, bei dem die Taste im Vergleich zu keystate als verändert erkannt wurde

ct1 ct0
1 1 // 3
1 0 // 2
0 1 // 1
0 0 // 0
1 1 // 3

<syntaxhighlight lang="c">
i &= ct0 & ct1; // count until roll over ?
</syntaxhighlight>
in i bleibt nur dort ein 1-Bit erhalten, wo sowohl in ct1 als auch in ct0 ein 1 Bit vorgefunden wird, der betreffende Zähler also bis 3 zählen konnte. Durch die zusätzliche Verundung mit i wird der Fall abgefangen, dass ein konstanter Zählerwert von 3 in i ein 1 Bit hinterlässt. Im Endergebnis bedeutet dass, dass nur ein Zählerwechsel von 0 auf 3 zu einem 1 Bit an der betreffenden Stelle in i führt, aber auch nur dann, wenn in i an dieser Bitposition ebenfalls ein 1 Bit war (welches wiederrum deswegen auf 1 war, weil an diesem Eingabeport eine Veränderung zum letzten bekannten entprellten Zustand festgestellt wurde). Alles zusammengenommen heißt das, dass ein Tastendruck dann erkannt wird, wenn die Taste 4 mal hintereinander in einem anderen Zustand vorgefunden wurde als dem zuletzt bekannten entprellten Tastenzustand.

An dieser Stelle ist i daher ein Vektor von 8 Bits, von denen jedes einzelne der Bits darüber Auskunft gibt, ob die entsprechende Taste mehrmals hintereinander im selben Zustand angetroffen wurde, der nicht mit dem zuletzt bekannten Tastenzustand übereinstimmt. Ist das der Fall, dann wird eine entsprechende Veränderung des Tastenzustands in key_state registriert
<syntaxhighlight lang="c">
key_state ^= i; // then toggle debounced state
</syntaxhighlight>
und wenn sich in key_state das entsprechende Bit von 0 auf 1 verändert hat, wird dieses Ereignis als 'Taste wurde niedergedrückt' gewertet.
<syntaxhighlight lang="c">
key_press |= key_state & i; // 0->1: key press detect
</syntaxhighlight>

Damit ist der Tasteneingang entprellt. Und zwar sowohl beim Drücken einer Taste als auch beim Loslassen (damit Tastenpreller beim Loslassen nicht mit dem Niederdrücken einer Taste verwechselt werden). Der weitere Code beschäftigt sich dann nur noch damit, diesen entprellten Tastenzustand weiter zu verarbeiten.

Der Codeteil sieht durch die Verwendung der vielen bitweisen Operationen relativ komplex aus. Behält man aber im Hinterkopf, dass einige der bitweisen wie ein 'paralles If' gleichzeitig auf allen 8 Bits eingesetzt werden, dann vereinfacht sich vieles. Ein
<syntaxhighlight lang="c">
key_press |= key_state & i;
</syntaxhighlight>
ist nichts anderes als ein
<syntaxhighlight lang="c">
// teste ob Bit 0 sowohl in key_state als auch in i gesetzt ist
// und setze Bit 0 in key_press, wenn das der Fall ist
if( ( key_state & ( 1 << 0 ) ) &&
( i & ( 1 << 0 ) )
key_press |= ( 1 << 0 );

// Bit 1
if( ( key_state & ( 1 << 1 ) ) &&
( i & ( 1 << 1 ) )
key_press |= ( 1 << 1 );

// Bit 2
if( ( key_state & ( 1 << 2 ) ) &&
( i & ( 1 << 2 ) )
key_press |= ( 1 << 2 );

...
</syntaxhighlight>
nur als wesentlich kompaktere Operation ausgeführt und für alle 8 Bits gleichzeitig.
Die Kürze und Effizienz dieser paar Codezeilen ergibt sich aus dem Umstand, dass jedes Bit in den Variablen für eine Taste steht und alle 8 (maximal möglichen) Tasten gleichzeitig die Operationen durchlaufen.

Funktionsweisen der verschienden Modi anhand von Zeitstrahlen erklärt:
https://www.mikrocontroller.net/topic/48465?goto=1753367#1844458

"Walkthrough" der verschiedenen Zuständer der Einzelnen Variablen anhand eines Tastendrucks (avrfreaks.net)
http://www.avrfreaks.net/comment/726676#comment-726676

===== Reduziert auf lediglich 1 Taste =====
Diskussionen im Forum zeigen immer wieder, dass viele eine Abneigung gegen diesen Code haben, weil er ihnen sehr kompliziert vorkommt.

Der Code ist nicht leicht zu analysieren und er zieht alle Register dessen, was möglich ist, um sowohl Laufzeit als auch Speicherverbrauch einzusparen. Oft hört man auch das Argument: Ich benötige ja nur eine Entprellung für 1 Taste, gibt es da nichts Einfacheres?

Hier ist die 'Langform' des Codes, so wie man das für lediglich 1 Taste schreiben würde, wenn man exakt dasselbe Entprellverfahren einsetzen würde. Man sieht: Da ist keine Hexerei dabei: In key_state wird der letzte bekannte entprellte Zustand der Taste gehalten. Der Pin-Eingang wird mit diesem Zustand verglichen und wenn sich die beiden unterscheiden, dann wird ein Zähler heruntergezählt. Produziert dieses herunterzählen einen Unterlauf des Zählers, dann gilt die Taste als entprellt und wenn dann auch noch die Taste gerade gedrückt ist, dann wird dieses in key_press entsprechend vermerkt.

<syntaxhighlight lang="c">
uint8_t key_state;
uint8_t key_counter;
volatile uint8_t key_press;

ISR( ... Overflow ... )
{
uint8_t input = KEY_PIN & ( 1 << KEY0 );

if( input != key_state ) {
key_counter--;
if( key_counter == 0xFF ) {
key_counter = 3;
key_state = input;
if( input )
key_press = TRUE;
}
}
else
key_counter = 3;

}

uint8_t get_key_press()
{
uint8_t result;

cli();
result = key_press;
key_press = FALSE;
sei();

return result;
}
</syntaxhighlight>

Der vollständige Entprellcode, wie weiter oben gelistet, besticht jetzt aber darin, dass er compiliert kleiner ist als diese anschaulichere Variante für lediglich 1 Taste. Und das bei gleichzeitig erhöhter Funktionalität. Denn zb. ein Autorepeat ist in diesem Code noch gar nicht eingebaut. Und spätestens wenn man dann eine 2.te Taste entprellen möchte, dann ist auch der SRAM-Speicherverbrauch dieser Langform höher als der des Originals für 8 Tasten. Daraus folgt: Selbst für lediglich 1 Taste ist die Originalroutine die bessere Wahl.

Und wegen der Komplexität mal eine Frage: Sind Sie selbst in der Lage eine entsprechend effiziente sqrt() Funktion zu schreiben, wie die, die sie in der Standard-C-Bibliothek vorfinden? Nein? Dann dürften Sie eigentlich Ihrer Argumentation nach die Bibliotheksfunktion sqrt() nicht verwenden, sondern müssten sich statt dessen selbst eine Wurzel-Funktion schreiben.

=== Selbstsättigendes Filter (nach Jürgen Schuhmacher) ===
Durch die Nutzung der diskreten Signalanalyse in Software kann die Funktionalität einer einfachen Entprellung mit einem Widerstand, einem Kondensator und einem Schmitttrigger wie in Hardware nachgebildet werden, indem ein abstraktes IIR-Filter benutzt wird, der eine Kondensatorladekurve emuliert. Mit der Vorschrift Y(t) = k Y(t-1) + Input wird ein einfaches Filter erzeugt, dass dem Eingangswert träge folgt. Bei Überschreiten eines bestimmten Wertes erfolgt mit einer einfachen Abfrage das Schalten des Ausgangssignals.

Für Assembler und VHDL bei FPGAs eignet sich aufgrund der leicht zu implementierenden binären Operationen folgende Darstellung mit einer Auflösung des Filterwertspeichers von nur 8 bit: Wert_Neu = Wert_Alt - Wert_Alt/16 + 16*(Taste = True). Der Filterwert bildet dann den gedämpften Verlauf des Eingangs (flankenverschliffen) ab und kann Prellen bis nahe an den Grenzbereich zum schnellen Tasten unterdrücken. Der Ausgangswert ist dann einfach das höchstwertige Bit des Filterwertes.

[[Datei:Entprellung mit IIR-Filter.gif]]

Dazu muss das Signal des Tasters idealerweise um den Faktor 10-20 schneller abgetastet werden, als die höchste gewünschte Tippgeschwindigkeit vorgibt. Noch schneller abzutasten ist möglich, führt aber zu mehr Bedarf an Bits beim Filter. Die Schmittriggerfunktion kann dadurch gebildet werden, dass eine 1 am Ausgang bei z.B. Überschreiten einer 55% Grenze und eine 0 bei Unterschreitung der 45%-Grenze ausgeben wird. Im Zwischenbereich wird der alte Wert gehalten. Die realen Grenzen dieser [[Hysterese]] müssen an die Applikation angepasst werden, da zu enge Grenzen sonst zu empfindlich gegenüber Störungen wären.

=== Einfaches Mittelwertfilter (nach Lothar Miller) ===
Für digitale Schaltungen oder PLDs empfiehlt sich ein FIR-Filter mit aneinandergereihten FlipFlops. Man schiebt das Eingangssignal in eine FlipFlop-Kette und schaltet oberhalb der Mitte um:

SignalInput -> FF1 -> FF2 -> FF3 -> FF4 -> FF5 -> FF6 -> FF7 -> FF8

Wenn alle FFs = 1 (Summe der FFs=8) dann SignalOutput = 1 
Wenn alle FFs = 0 (Summe der FFs=0) dann SignalOutput = 0

Dieses Verfahren kann sehr einfach in Logik abgebildet werden, weil für die Berechnung des Ausgangs nur ein NOR bz. ein AND Gatter nötig ist.

Das reale Signal muss dazu aber genügend langsam abgetastet werden, sodaß die Filterperiode die Prelldauer übersteigt, um zu verhindern, daß nicht inmitten einer passiven Phase eines Prellvorgangs ein 8fach 1 gesehen wird. Damit wird die Interetation vergleichsweise langsam.

== Gegenüberstellung der Verfahren ==
* HW - "entprellte Schalter": Sehr teuer, grosse Bauform, verschleissbelastet, geringe Haltbarkeit
* HW - "Umschalter" : benötigt aufwändigeren Schalter, benötigt Elektronik
* HW - "Umschalter ohne FF" : benötigt aufwändigeren Schalter und kleinen Kondensator
* HW - "Kondensatorentprellung" : benötigt etwas mehr Platz, kommt mit schlechten Schaltern zurecht

* SW - Flankenverfahren:
* SW - Warteschleife: Durch die Warteschleifen eine nicht zu vernachlässigende Verzögerung im Code. Speziell wenn mehrere Tasten zu überwachen sind, nicht unproblematisch
* SW - Timer: Universalfunktionalität, die durch geringen Speicherverbrauch, geringen Rechenzeitverbrauch und gute Funktion besticht. Der 'Verbrauch' eines Timers sieht auf den ersten Blick schlimmer aus, als er ist, denn in den meisten Programmen hat man sowieso einen Basistimer für die Zeitsteuerung des Programms im Einsatz, der für die Tastenentprellung mitbenutzt werden kann.
* SW - Filter: sehr geringer Platzbedarf in FPGAs, relativ gute Wirkung
* SW - Filter 2: sehr geringer Platzbedarf, gute Wirkung

== Links zum Thema ==

* [http://www.edn.com/design/analog/4324067/Contact-debouncing-algorithm-emulates-Schmitt-trigger Contact-debouncing algorithm (Artikel)], [http://www.edn.com/Pdf/ViewPdf?contentItemId=4324067 als PDF]
* [[AVR-Tutorial: Tasten]]
* [[AVR-GCC-Tutorial#.28Tasten-.29Entprellung|AVR-GCC-Tutorial Tastenentprellung]]
* [http://www.mikrocontroller.net/forum/read-4-20435.html Beitrag im Forum, AVR Assembler]
* [http://www.ganssle.com/debouncing.pdf A guide to debouncing (engl.), praktische Erläuterungen zum Entprellen in Soft- und Hardware]
* [http://www.pololu.com/docs/0J16/all Understanding Destructive LC Voltage Spikes]

[[Kategorie:AVR]]
[[Kategorie:Signalverarbeitung]]

Erweiterung von digitalen IO-Ports

2022-01-23T03:24:59Z

172.26.38.125: /* Schieberegister mir Dämpfung */ t

Für manche Aufgaben in Microcontrollern und digitalen Bausteinen werden oftmals digitale Steuersignale oder analoge Ausgangspannungen benötigt, die nur relativ langsam geändert werden müssen. Sollen dafür keine zusätzlichen Chips oder unnötig viele Pins am Controller verwendet werden, lässt sich die Zahl der Ports erweitern indem folgende Schaltungen eingesetzt werden:

== Schieberegister mit Dämpfung==

[[Datei:Erweiterung digitaler ausgaenge 1.png|thumb|right|320px|Multiplex-PWM als Port-Erweiterung für FPGAs]]
Die Schaltung besteht aus einem Schieberegister, das mit einem schnellen Taktsignal getrieben wird. Es erzeugt am Ausgang 4 unabhängige digitale Signale, die sich infolge der Dämpfungsglieder nicht direkt auswirken können. Bei einer geringen Zeitkonstante werden so glitches vermieden und es entstehen in der Flankensteilheit einstellbare digitale Signale. Wichtig ist, dass das zeitliche Verhältnis zwischen Umschaltphasen und statischen Signalen günstig genug ist. Bei sehr hohen Zeitkonstanten werden auf diese Weise multiplexte PWM-Ausgänge geschaffen, die mit bis zu etwa einem 1/4-tel der Taktfrequenz arbeiten können. Die kurzzeitig fehlerhaften Schaltungszustände, die beim Durchtakten eines neuen Musters entstehen, werden so bereits gut gedämpft, sodass quasi analoge Signale entstehen. Ferner können die Umschalteffekte bei der PWM-Generation berücksichtigt werden. Um sie als echte digitale Ausgänge nutzen zu können, kann ein Buffer mit Schmitt-Trigger nachgeschaltet werden, der auch als Leistungstreiber agieren kann.
{{Absatz}}

== Schieberegister mit Latch==

[[Datei:Erweiterung digitaler ausgaenge 2.png|thumb|right|320px|Stabile Zusatzports mit Latch]]
Werden reine digitale Ausgänge mit hoher Qualität benötigt, die nicht zittern / glitchen dürfen, sollte ein Latch eingesetzt werden, das dann sogar mit einem der künstlich erzeugten Bits getaktet werden kann. Dazu muessen aber doppelt soviele Befehlssequenzen ausgegeben werden, damit das Latch-enable eine 0/1 sehen und schalten kann. Es sollte ein Latch mit Schmitt-Trigger-Eingängen verwendet werden.

Sicherer ist natürlich die Methode, den Takt zu trennen und insgesamt 3 Pins des Controllers oder FPGAs zu verwenden.

{{Absatz}}

Dafür eignen sich die Bausteine HC165 und HC595.

== Links ==
* Artikel zur PWM-Glättung: [[Glättungsfilter für 1-Bit DA-Wandlung|1-Bit Digital-Analog-Wandlung]]
* Porterweiterung mit SPI : [[Porterweiterung mit SPI]]
* Porterweiterung mit Standard-Chips : [[Porterweiterungen]]

[[Kategorie:Grundlagen]]
[[Kategorie:Bauteile]]
[[Kategorie:Portexpander]]

Erweiterung von digitalen IO-Ports

2022-01-23T03:24:42Z

172.26.38.125: /* Schieberegister mit Latch */

Für manche Aufgaben in Microcontrollern und digitalen Bausteinen werden oftmals digitale Steuersignale oder analoge Ausgangspannungen benötigt, die nur relativ langsam geändert werden müssen. Sollen dafür keine zusätzlichen Chips oder unnötig viele Pins am Controller verwendet werden, lässt sich die Zahl der Ports erweitern indem folgende Schaltungen eingesetzt werden:

== Schieberegister mir Dämpfung==

[[Datei:Erweiterung digitaler ausgaenge 1.png|thumb|right|320px|Multiplex-PWM als Port-Erweiterung für FPGAs]]
Die Schaltung besteht aus einem Schieberegister, das mit einem schnellen Taktsignal getrieben wird. Es erzeugt am Ausgang 4 unabhängige digitale Signale, die sich infolge der Dämpfungsglieder nicht direkt auswirken können. Bei einer geringen Zeitkonstante werden so glitches vermieden und es entstehen in der Flankensteilheit einstellbare digitale Signale. Wichtig ist, dass das zeitliche Verhältnis zwischen Umschaltphasen und statischen Signalen günstig genug ist. Bei sehr hohen Zeitkonstanten werden auf diese Weise multiplexte PWM-Ausgänge geschaffen, die mit bis zu etwa einem 1/4-tel der Taktfrequenz arbeiten können. Die kurzzeitig fehlerhaften Schaltungszustände, die beim Durchtakten eines neuen Musters entstehen, werden so bereits gut gedämpft, sodass quasi analoge Signale entstehen. Ferner können die Umschalteffekte bei der PWM-Generation berücksichtigt werden. Um sie als echte digitale Ausgänge nutzen zu können, kann ein Buffer mit Schmitt-Trigger nachgeschaltet werden, der auch als Leistungstreiber agieren kann.
{{Absatz}}

== Schieberegister mit Latch==

[[Datei:Erweiterung digitaler ausgaenge 2.png|thumb|right|320px|Stabile Zusatzports mit Latch]]
Werden reine digitale Ausgänge mit hoher Qualität benötigt, die nicht zittern / glitchen dürfen, sollte ein Latch eingesetzt werden, das dann sogar mit einem der künstlich erzeugten Bits getaktet werden kann. Dazu muessen aber doppelt soviele Befehlssequenzen ausgegeben werden, damit das Latch-enable eine 0/1 sehen und schalten kann. Es sollte ein Latch mit Schmitt-Trigger-Eingängen verwendet werden.

Sicherer ist natürlich die Methode, den Takt zu trennen und insgesamt 3 Pins des Controllers oder FPGAs zu verwenden.

{{Absatz}}

Dafür eignen sich die Bausteine HC165 und HC595.

== Links ==
* Artikel zur PWM-Glättung: [[Glättungsfilter für 1-Bit DA-Wandlung|1-Bit Digital-Analog-Wandlung]]
* Porterweiterung mit SPI : [[Porterweiterung mit SPI]]
* Porterweiterung mit Standard-Chips : [[Porterweiterungen]]

[[Kategorie:Grundlagen]]
[[Kategorie:Bauteile]]
[[Kategorie:Portexpander]]

Erweiterung von digitalen IO-Ports

2022-01-23T03:19:50Z

172.26.38.125: so macht das Sinn - das sind 2 verschiedene Dinge

Für manche Aufgaben in Microcontrollern und digitalen Bausteinen werden oftmals digitale Steuersignale oder analoge Ausgangspannungen benötigt, die nur relativ langsam geändert werden müssen. Sollen dafür keine zusätzlichen Chips oder unnötig viele Pins am Controller verwendet werden, lässt sich die Zahl der Ports erweitern indem folgende Schaltungen eingesetzt werden:

== Schieberegister mir Dämpfung==

[[Datei:Erweiterung digitaler ausgaenge 1.png|thumb|right|320px|Multiplex-PWM als Port-Erweiterung für FPGAs]]
Die Schaltung besteht aus einem Schieberegister, das mit einem schnellen Taktsignal getrieben wird. Es erzeugt am Ausgang 4 unabhängige digitale Signale, die sich infolge der Dämpfungsglieder nicht direkt auswirken können. Bei einer geringen Zeitkonstante werden so glitches vermieden und es entstehen in der Flankensteilheit einstellbare digitale Signale. Wichtig ist, dass das zeitliche Verhältnis zwischen Umschaltphasen und statischen Signalen günstig genug ist. Bei sehr hohen Zeitkonstanten werden auf diese Weise multiplexte PWM-Ausgänge geschaffen, die mit bis zu etwa einem 1/4-tel der Taktfrequenz arbeiten können. Die kurzzeitig fehlerhaften Schaltungszustände, die beim Durchtakten eines neuen Musters entstehen, werden so bereits gut gedämpft, sodass quasi analoge Signale entstehen. Ferner können die Umschalteffekte bei der PWM-Generation berücksichtigt werden. Um sie als echte digitale Ausgänge nutzen zu können, kann ein Buffer mit Schmitt-Trigger nachgeschaltet werden, der auch als Leistungstreiber agieren kann.
{{Absatz}}

== Schieberegister mit Latch==

[[Datei:Erweiterung digitaler ausgaenge 2.png|thumb|right|320px|Stabile Zusatzports mit Latch]]
Ist ein reiner digitaler Ausgang benötigt, der nicht zittern darf, sollte ein Latch eingesetzt werden, das dann mit nur einem der künstlich erzeugten Bits getaktet werden muss. Dazu muessen doppelt soviele Befehlssequenzen ausgegeben werden, wobei das Latch-enable eine 0/1 sehen muss. Es sollte ein Latch mit Schmitt-Trigger-Eingängen verwendet werden.

{{Absatz}}

Dafür eignen sich die Bausteine HC165 und HC595.

== Links ==
* Artikel zur PWM-Glättung: [[Glättungsfilter für 1-Bit DA-Wandlung|1-Bit Digital-Analog-Wandlung]]
* Porterweiterung mit SPI : [[Porterweiterung mit SPI]]
* Porterweiterung mit Standard-Chips : [[Porterweiterungen]]

[[Kategorie:Grundlagen]]
[[Kategorie:Bauteile]]
[[Kategorie:Portexpander]]

Absolute Beginner

2022-01-13T06:09:17Z

172.26.38.125: /* Sinnvolles Wissen */

[[Category:Grundlagen]]

==Einleitung==
<div align="center">
Gestern tat es einen Schlag, 
wovon ich hier berichten mag. 

Drosselspulen, Widerstände, 
alles fällt mir in die Hände. 
Da bau ich eine Schaltung auf. 
Ein Kühlblech kommt da auch noch drauf. 
An Einstellreglern rumgedreht, 
bis dann plötzlich nichts mehr geht. 
Elkos hab ich nicht gebraucht, 
Widerstände abgeraucht. 
Jetzt ist die Bude voller Qualm, 
zum Himmel schick ich einen Psalm. 
Transistoren an den Ohren. 
Dioden an den Hoden. 
Kabel am Nabel. 
Phase an der Nase! 
Herzkammer flimmert; kann nur noch fluchen. 
Muß mir ein neues Hobby suchen! 
MfG Paul </div>

 
Damit dieses von Paul so plastisch dargestellte Anfängerszenario gar nicht erst eintritt, werden auf dieser Artikelseite von http://www.mikrocontroller.net einige Dinge aufgeführt, die unbedingt notwendig sind, wenn man sich mit Elektronikbasteleien auseinandersetzt. Die Seite richtet sich bewusst an den absoluten Anfänger um so interessierten Leuten den Einstieg in die Welt der Elektronik und damit auch zum Programmieren von Mikrocontrollern möglichst einfach zu gestalten.

Natürlich ist das Programmieren von Mikrocontrollern auch ohne Elektronikkenntnisse machbar, aber die Aussenanbindung eines Mikrocontrollers zu verstehen ist häufig sinnvoll, so z. B. wenn man ein Signal auswerten möchte.

Die Grundlage für diesen Artikel bildet dieser [http://www.mikrocontroller.net/forum/read-1-344257.html#new Thread] aus dem Forum.

==Sicherheit==

Bleibt gesund! Denkt daran, dass nicht nur Strom und Spannung bei dem neuen interessanten Hobby gefährlich sein können, sondern auch Hitze, Licht (Laser), Schall, Chemikalien (Entwickler, Ätzbäder, Lötrauch) usw. Lieber einmal mehr fragen, als einmal zu wenig. Und vielleicht bewahrt eure Frage euch und den Nächsten vor Schaden!

===Versuchsaufbauten >60V (DC)===
Tipp aus dem Forum [http://www.mikrocontroller.net/topic/181266#1750311]:
<pre>
Diplomand schrieb:
> Oder wie geht es auf'er Arbeit zu in Puncto
> Versuchsaufbauten?

Alles was über 60V (DC) ist muß bei anliegender Spannung
mindestens unter 1 cm dickes Plexiglas.

Gruß Anja
</pre>

==Literatur==
Ohne Lektüre (egal ob in Papierform oder im Internet) wird das mit der Elektronik in Eigenregie nix.
Möchte man sich ernsthaft mit der Materie beschäftigen, so kommt man nicht umhin, sich mit den Grundlagen der Elektronik zu beschäftigen. Während man im Internet viele Schaltungen findet, die einfach nachzubauen sind, bietet sich für das Grundlagenstudium eher ein Buch an. Da gute Elektronikbücher häufig teuer sind, will ich Dir folgenden Tipp geben: Schau einfach mal in die nächste größere Bibliothek. Wenn Dir ein Buch dort gefällt, kannst Du es jederzeit noch kaufen. Wer sich nicht irgendwann mit den Grundlagen beschäftigt, wird nie über das Stadium herauskommen, in dem er Schaltungen aus dem Internet kopiert. Aber unser aller Ziel ist es doch, auch zu verstehen, weshalb hier jetzt genau der rot-rot-schwarze Widerstand rein muss und was er tut...
*'''Fachzeitschriften''' am Kiosk
*'''Internet'''
**'''[http://www.elektronik-kompendium.de/ Das Elektronik Kompendium]''' Ziel von das ELKO ist es die Themen Elektronik, Computertechnik, Kommunikationstechnik und Netzwerktechnik allgemeinverständlich zu erklären und der Allgemeinheit zu präsentieren. Die Zielgruppe sind vor allem Schüler und Auszubildende, die sich mit Elektronik näher beschäftigen müssen oder wollen. Weiterhin sollen alle privat und beruflich an Elektronik interessierte angesprochen werden.
**'''http://www.dse-faq.elektronik-kompendium.de/''' Es gibt zwar von der Startseite des ELKO einen Link zum FAQ, aber es schadet sicher nicht, es hier explizit aufzuführen.
**'''http://www.b-kainka.de/'''
**'''http://www.dieelektronikerseite.de/'''
**'''http://www.howstuffworks.com/'''
**'''Datenblatt (Datasheet)''' zu den meisten Bauteilen, wird vom Hersteller ein Datasheet angeboten. Es ist sinnvoll, dies wenigstens einmal durchzulesen, auch wenn man am Anfang wenig mit den ganzen Fachbegriffen anfangen kann.
**Diverse Application Notes der großen Halbleiterhersteller sind auch immer eine gute Informationsquelle und beschäftigen sich teilweise auch mit sehr grundlegenden Problemen
*'''Bücher''' --- (letzte Änderung: 10.2.2020)
**'''[https://www.amazon.de/Art-Electronics-Paul-Horowitz/dp/0521809266/ref=sr_1_1?__mk_de_DE=%C3%85M%C3%85%C5%BD%C3%95%C3%91&keywords=the+art+of+electronics&qid=1581325802&sr=8-1 The Art of Electronics]''' Third Edition, von P.Horowitz, W.Hill - ISBN 978-0-521-80926-9 - Bitte nur die englische Version nutzen, da die Übersetzung nicht gut gelungen ist.
** '''[http://www.amazon.de/exec/obidos/ASIN/3426037920/qid=1146692611/sr=8-1/ref=sr_8_xs_ap_i1_xgl/302-0461878-1759243 Elektronik ohne Geheimnisse]''' Von der Anfängerschaltung bis zum Radio, Franzis-Verlag, ISBN 3-426-03792-0
**'''[https://www.thalia.de/shop/home/artikeldetails/ID30574703.html Elemente der angewandten Elektronik]''' von E.Böhmer, D.Ehrhardt, W.Oberschelp, Springer Vieweg, ISBN 978-3-8348-1496-8
**'''[https://www.thalia.de/shop/home/artikeldetails/ID143929448.html Halbleiter-Schaltungstechnik]''', von U.Tietze, Ch.Schenk, E.Gamm, Springer Vieweg, ISBN 978-3-662-48553-8 - ältere Auflagen können günstig antiquarisch erworben werden, z.B. bei: [https://www.medimops.de/produkte-C0/?listorder=asc&listorderby=oxvarminprice&searchparam=Halbleiter-Schaltungstechnik Medimops.de]
**'''Schaltkreisbastelbuch''' von H.Jakubaschk und das
**'''Radiobastelbuch''' von K.H. Schubert. Das sind sehr alte DDR-Bücher. Aber die sind für Einsteiger äußerst nahrhaft.
**'''Tabellenbuch''' ein beliebiges Elektronik Tabellenbuch, hier findest Du die mathematischen Grundlagen als Formelsammlung. Es wird Dich als Nachschlagewerk bis zur Rente begleiten.
** [http://www.generalatomic.com/teil1/index.html Das Telekosmos-Praktikum (Teil 1)]
** '''[http://www.amazon.de/Elektronik-nicht-schwer-Experimente-Gleichstrom/dp/3921608325 Elektronik - gar nicht schwer]''' Es gibt davon verschiedene Bände. Band 1 ist für den absoluten Einstieg gut, allerdings sind die Schaltungen darin für etwas Fortgeschrittene nicht mehr besonders interesssant. Band 2 hingegen ist sowohl für Einsteiger als auch für Fortgeschrittene empfehlenswert!
** '''[http://stefanfrings.de/mikrocontroller_buch2/index.html Einblick in die moderne Elektronik ohne viel Theorie] PDF

==Grundausstattung für das Elektroniklabor==
In der folgenden Liste werden die wichtigsten Bauteile aufgeführt, die in keinem Elektroniklabor fehlen dürfen. Da es eine Unmenge an Angeboten der einzelnen Bauteile gibt, wird auf der Seite [[Standardbauelemente]] darauf hingewiesen, welche Bauteile sich im Laufe der Zeit als sinnvoll dargestellt haben.

* [[Steckbrett]] Mit dem Steckbrett (Breadboard) kann man schnell und ohne Lötkolben eine Schaltung zum Testen aufbauen.
* [[Steckbrücken und Kabel]] Ein farbcodiertes Steckbrückenset [http://www.ebay.de/sch/items/?_nkw=Steckbr%C3%BCcken+Set] macht das Verkabeln einfacher. Dazu noch ein Sortiment an Kabeln [http://www.ebay.de/sch/items/?_nkw=Jumper+Wires]. Zur Auswahl des richtigen Drahts fürs Steckbrett sind in folgendem Thread nützliche Informationen zu finden: [http://www.mikrocontroller.net/forum/read-1-350462.html#new].
*'''Widerstände:''' 330 Ω, 1 kΩ, 3.3 kΩ, 10 kΩ, 100 kΩ, 1 MΩ (lies: "Ohm"/"Kilo-Ohm"/"Mega-Ohm"). Ob man sich Kohleschicht- oder Metallfilmwiderstände kauft, ist zunächst unerheblich.
*'''Potentiometer:''' 1 kΩ, 10 kΩ, 100 kΩ
*'''Elektrolytkondensatoren''' ("Elkos"): 1 µF, 10 µF, 100 µF, 470 µF, 1000 µF, 2200 µF (lies: "Mikro-Farad"). Eine Spannungsfestigkeit von 25 Volt ist für den Anfang ausreichend.
*'''Keramikkondensatoren:''' 100 nF; 22 pF (letztere für Quarze)
*'''Dioden:''' 1N4148, 1N4007; BAT43 oder BAT85 (Schottky)
*'''[[LED]]s''' verschiedenfarbig, je nach Geschmack. Man sollte zumindest einige Farben haben, um unterschiedliche Betriebszustände u.ä. anzuzeigen.
*'''[[Transistor]]en:''' BC547, BC557 (Dies sind die beiden Standard npn- bzw. pnp-Transistortypen) und BC327, BC337 (höherer Kollektorstrom, trotzdem Standard)
*'''Operationsverstärker ("OPV" oder "OpAmp"):''' LM324 (der LM741 ist weniger gut geeignet)
*'''Universal-Timer-IC:''' NE555. Wenn man mit 3,3V Mikrocontrollern arbeitet, dann eventuell die nur wenige Cent teureren CMOS-Version wie LM'''C'''555, I'''C'''M7555, TS555, TM'''C'''555, usw. Diese lassen sich mit niedrigeren Betriebsspannungen betreiben (Datenblatt checken!), während der bipolare NE555 etwa mindestens 4,5V benötigt.
*'''[[AVR-Tutorial:_Equipment#Spannungsversorgung|Spannungsregler]]:''' Ein 7805-Festspannungsregler für die Bereitstellung von 5 V ist sinnvoll, wenn man mal eine Schaltung autark betreiben will. Dann benötigt man in den meisten Fällen noch einen geeigneten Trafo mit einem Brückengleichrichter und einem Glättungskondensator oder ein kleines Steckernetzteil als Basisversorgung für den Spannungsregler. Ein regelbares Netzteil mit Anzeige ist ebenfalls einsetzbar, birgt aber eine Gefahr in sich. Einige ICs, darunter Mikrocontroller, haben enge Betriebsgrenzen, in denen sie funktionieren bzw. oberhalb denen sie sterben (siehe unter ''Absolute Maximum Ratings'' im Datenblatt). Irgendwann ist der Stellknopf am Labornetzteil dann doch höhergestellt, als es dem Chip gut tut...
*'''Schalter''' einfache Schiebeschalter (EIN/AUS)
*'''Taster: ''' Bedrahtet oder SMD Kurzhubtaster (billiger). Für Verwendung mit einem Mikrocontroller müssen diese softwareseitig [[Entprellung|entprellt]] werden.
*'''Lötnägel''' Sind dazu gedacht, auf Platinen eingelötet zu werden. Auf Breadboards haben sie nichts verloren, weil sie mit einem Durchmesser von 1 mm dafür zu dick sind.
* '''Jumperpins''': gibt es als 40polige Leiste, die man mit dem Seitenschneider kürzen kann.
* '''Ein Satz Schnellverbinder-Kabel''' mit Krokodilklemmen an beiden Enden
*'''Draht'''
** dünne Litze,
** dünner isolierter Draht (je dünner desto besser), ideal: Wrap-Draht ca. AWG30, leider etwas schwer erhältlich und teuer, (alte 80-polige IDE-Kabel sind meist AWG30)
** dünner blanker verzinnter Draht (möglichst < 0,5mm, leider etwas schwer erhältlich) oder lötbarer Silberdraht,
* Ein paar '''Lochraster-Platinen''' mit Lötpunkten, falls man doch nicht nur stecken und nachher auseinanderbauen will. '''Streifenraster-Platinen''' sparen ein paar Löt- oder Drahtbrücken.

Installationskabel, dicke 230V-Litze oder Klingeldraht sollte man zum Aufbau von Lochraster-Schaltungen nicht verwenden. Leitungen mit größerem Querschnitt kommen nur zum Einsatz, wenn hohe Ströme fließen sollen.

Zur Aufbewahrung der Kleinteile ist ein Kleinteilemagazin oder einige Sortimentkästen sehr zu empfehlen. Man muss sich nicht von vornherein auf spezielle Bauteile festlegen.

Eine weiterreichende Liste von Standard-Bauelementen findet sich [[Standardbauelemente|hier]].

==Werkzeug==
* Eine eigene '''Bastelecke''', in der ein Aufbau auch mal ein, zwei Wochen [http://www.mikrocontroller.net/topic/15027#104245 liegenbleiben] kann, bis man wieder Lust oder Zeit hat, was daran zu machen. Bau Dir den Schreibtisch vorm PC nicht zu – Du brauchst den Zugang hierher ;-)

* Eine '''stabile Unterlage''', die nicht leitend ist, z. B. eine Holzplatte. Die nimmt es im Gegensatz zum Wohnzimmertisch nicht übel, wenn der Lötkolben mal umfällt und einen Brandfleck hinterlässt, oder wenn abgeknipste, scharfe Drahtspitzen (Platinenunterseiten!) kratzen. Eine Anti-Statik-Matte (mit angeschlossener Erdung!!) ist auch eine Überlegung wert, sie bewahrt evtl vor unangenehmen Überraschungen und langer Fehlersuche.

* Eine '''Halterung''' um Dinge fixieren zu können. Anfangs tut's die [http://www.ebay.de/sch/items/?_nkw=Dritte+Hand dritte Hand].

* Ein '''kleiner Schraubendreher''' als Allzweckwerkzeug zum Drücken, Klopfen, Justieren, ICs-aus-dem-Sockel-hebeln, Kabel beim Löten Fixieren. Ach ja, Schrauben drehen kann man damit auch.

* Eine gute, spitze '''Pinzette''' zum Greifen und Richten kleiner Bauteile, Drähte einstecken usw. Außerdem eine Klemmpinzette mit flacher Spitze zum Fixieren von Bauteilen.

* Ein '''Seitenschneider''', klein, zum Durchtrennen von Drähten. Opas Kneifzange ist ungeeignet, Omas Handarbeitsschere auch.

* Eine '''Spitzzange''', klein, für alles, wofür die Pinzette nicht kräftig genug ist.

* Eine '''Abisolierzange''', Bauform vgl. Wasserrohrzange. Die symmetrischen mit dem Loch vorne sind eher für Starkstromleitungen gedacht.

* Ein '''Skalpell''' als Allzweckwaffe. Wenn man es einmal hat, will man es nicht mehr missen.

* Ein '''Cuttermesser''' für alles grobe wofür das Skalpell zu schade ist und wo die Abisolierzange und der Seitenschneider versagt.

* Eine '''Grundausrüstung zum Löten'''. Detaillierte Informationen zum Löten findest Du im Artikel [[Löten_(praktisch)]].
** '''Lötkolben''' 30 Watt ungeregelt oder mehr als 30 Watt mit Regelung
** ''' Lötzinn''' 1 mm
** '''Lötschwamm '''. Ein gut mit Wasser angefeuchteter Baumwoll-Lumpen (gefaltete "Jute-Tasche") tut es auch. Destillierte Wasser ist auf Dauer besser als Leitungswasser.
** Eine '''Entlötpumpe''' oder '''Entlötlitze''' zum Fehler auszubessern.

* Eine kleine '''(LED-) Taschenlampe''' und eine Lupe, um Bauteile wie Dioden oder schwach bedruckte IC's zu beleuchten und um deren Beschriftung erkennen zu können. Das Tageslicht kann gelegentlich zu "dunkel" sein.

* Eine '''Crimpzange''' und die entsprechenden Crimp-Kontakte und Leergehäuse. Macht das Basteln auf Dauer einfacher, da sich Kabel mit passender Länge und passendem Ende (Pin oder Buchse) schnell und ohne Löten herstellen lassen. Ausserdem scheiden irgendwelche Verlängerungen oder Isolierbandkonstruktionen als Fehlerquelle aus.

* Ein '''Netzteil mit Strombegrenzung''' hilft zu verhindern, dass Dir ständig die Bauteile flöten gehen. Oder Du nimmst deine Schaltungen zunächst mit Batterien oder Akkus in Betrieb, dann kostet es "nur" die Schaltung. Denn bei Batterien/Akkus ist auch darauf zu achten, dass bei einem Kurzschluss sehr hohe Ströme fließen können! Als Strombegrenzung für die Schaltung kann bei kleinen Aufbauten eine 6 V/100 mA Glühlampe in Serie benutzt werden ([http://www.mikrocontroller.net/topic/61119#480376 Forenbeitrag]). Bei einem Kurzschluss heizt sich durch den hohen Strom der Faden auf, die Lampe wird hell, der Widerstand des Fadens nimmt zu, und es können nur die 100 mA zur Schaltung kommen.

* Ein '''[http://de.wikipedia.org/wiki/Multimeter Multimeter]''' zum Messen von Spannungen, Strömen und Widerständen. Eine Überlegung wert ist der Kauf zweier Multimeter, weil man dann z. B. gleichzeitig Strom und Spannung messen kann. Prüfspitzen in Klemmausführung haben den Vorteil, dass man die Hände frei hat für wichtigere Dinge. [http://de.wikipedia.org/wiki/Digitalmultimeter Digitale Multimeter] sind in der Regel günstiger als die analogen (Beispiel: 4,95 € bei [http://www.pollin.de pollin]). Für den Anfang reicht normalerweise ein günstiges Gerät, später könnte aber dessen mangelnde Genauigkeit doch einigen Frust erzeugen - das ggf gleich ein paar Euro mehr ausgeben.

* Ein '''[[Oszilloskop]]''' ist zu Beginn noch nicht unbedingt notwendig, schadet aber nicht. Ein '''[[Logikanalysator]]''' ist für Digital-Schaltungen auch schon hilfreich und ggf. billiger. Wenn man sich eine Weile mit der Materie beschäftigt, kommt die Wünsche von ganz alleine. Ein kleiner Ratgeber zur Auswahl von Geräten findet sich hier im Wiki. ''Tip:''Für I2C, SPI und UART reicht bei niedrigen Raten (bis so 16kHz) oft ein PC-Oszilloskop mit einem etwas veränderten Mikrofonkabel. Das Selber-Bauen eines Logikanalysators ist ein interessantes Projekt (siehe [[Logic_Analyzer]]), erreicht aber oft nicht die gewünschten Funktionen und Bandbreite - oder scheitert schon an dem grundlegenden [http://de.wikipedia.org/wiki/Henne-Ei-Problem Henne-Ei Problem].

==Software==
* Ein '''Simulationstool''' ist nützlich. Mit Simulationsprogrammen kann man sich viel Zeit und Frust ersparen. Man weiß bereits vor dem Aufbau, ob eine Schaltung NICHT funktionieren wird. Der Umkehrschluss ("Das funktioniert dann auch in Echt") ist leider nicht immer möglich.
:Viele kommerzielle, aber auch kostenlos erhältliche Simulationsprogramme sind Abkömmlinge eines Programms namens '''[[SPICE]]'''. Z.B. enthalten die folgenden Programme nicht ganz zufällig je einen SPICE-Kern für die eigentliche Berechnung. Im Gegensatz zum Original-SPICE bieten sie jedoch den Vorteil einer grafischen Benutzeroberfläche.

**Mit Hilfe von [https://www.tinkercad.com/learn/circuits '''Tinkercad Circuits''' ] kannst Du Schaltungen am Computer planen und sogar ohne Arduino testen. Viel mehr noch könnte man sagen, dass Tinkercad einen kompletten Arduino(Atmega328P) simuliert. Tinkercad besitzt standardmäßig einen Atmega328P womit man im Browser programmiert und ein paar Standard-Bauteile(Liste kann ausgeklappt werden) besitzt.
<div class="mw-collapsible mw-collapsed">
***DC-Motoren
***Servomotoren
***Widerstände
***ICs
***Kondensatoren
***Spulen
***Taster/Schalter
***Potentiometer
***Lichtsensoren
***Bewegungs-/Näherungsensoren
***Gas-Sensoren
***Zahlenfeld
***Dipswitches (Mäuseklavier)
***Dioden
***LED Ringe
***Piezo
***IR Fernbedienung
***LED- und LCD-Displays
***Batterien
***Breadboards
***Arduino
***Multimeter
***Labornetzteil
***Oscilloscope
***Integrierte Schaltkreise (ICs)
***Transistoren
***Relais
***W-LAN-Modul
</div>

** Die '''[http://www.electronicsworkbench.com/ Electronic Workbench]''' (aktuelle Versionen heißen '''NI Multisim''', nachdem der Hersteller von National Instruments übernommen wurde) ist in einigen Fachbüchern (s. Franzis Verlag) als abgespeckte Version mit einem geringeren Umfang an simulierbaren Bauteilen beigelegt und als [http://digital.ni.com/worldwide/germany.nsf/web/all/23834AA0D635C68586257124004EF1C9#3 Studentenversion günstiger erhältlich].
** '''[http://www.linear.com/designtools/software/#Spice SwitcherCAD III/LTspice]''' wird vom Hersteller Linear Technology kostenlos abgegeben. Eigentlich zur Unterstützung bei der Entwicklung von Anwendungen mit Linear Technology Produkten gedacht, enthält es doch einen kompletten SPICE-Kern.
** Das früher sehr populäre '''PSpice''' (erste PC SPICE Version, von der es eine kostenlose ''Student Edition'' gab) wurde mittlerweile von Cadence übernommen und in die OrCAD-Produktlinie integriert. Dabei ist die Student Edition weggefallen. Es gibt statt dessen eine '''[http://www.cadence.com/products/orcad/downloads/orcad_demo/index.aspx OrCAD PCB Demo-CD]''', auf der auch eine eingeschränkte PSpice-Version enthalten ist.
** '''[http://ngspice.sourceforge.net/screens.html ngspice]''' ist eine mit diversen Erweiterungen versehene Freie-Software Version von SPICE für diverse Unix Systeme (Solaris, Linux, Mac OS X, etc.) und Windows XP. Es enthält eine graphische Ausgabe, jedoch selber keine graphische, sondern nur eine Texteingabe. Es ist Teil von '''[http://www.geda.seul.org/ gEDA]''', einer Sammlung von freien ''Electronic Design Automation''-Werkzeugen, zu denen auch '''gschem''' als Schaltplan-Editor gehört. Was zur nächsten Kategorie führt:
** '''[http://qucs.sourceforge.net QUCS]''' ist ein gutes Simulationsprogramm, welches sich nicht nur zu Lernzwecken eignet, sondern auch zur Simulation von "echten" Schaltungen (Bauteilkatalog mit Strg-4 abrufen). Nützlich ist die Einbindung der Graphen direkt in den Schaltungseditor, da man so "alles auf einem Blick hat".
** '''[http://ktechlab.org/ KTechLab]''' ist eine Echtzeitsimulation von analogen und digitalen Bauelementen in Kombination mit PIC-Mikrocontrollern.
** '''[http://www.falstad.com/circuit/ P. Falstads Circuit Simulator]''' ist ein Java-Applet, das man direkt aus dem Browser heraus ausführen kann. Die Möglichkeiten sind zwar nicht ganz so umfangreich wie bei den anderen genannten Simulatoren, trotzdem lässt sich mit dem Applet schnell und einfach eine Schaltung simulieren (Vorteil: Programm muss nicht erst installiert werden)
So kann das gesamte Mikrocontrollerprojekt simuliert werden. Aber auch in die Transistor/Operationsverstärker/Logiktechnik kann man sich mit dem Programm gut
einarbeiten.
* Ein '''Schaltplaneditor''' (''schematic capturer'') ist nützlich z. B.
** '''[http://www.abacom-online.de/html/splan.html sEdit ]''' Software für Windows auch als Freewareversion geeignet.
**'''[http://www.cadsoft.de/ Eagle von Cadsoft]''' Der Quasi-Standard für Hobbyanwender. Es ist zwar etwas gewöhnungsbedürftig in der Bedienung, aber wenn man erstmal dahintergekommen ist, was sich Cadsoft dabei gedacht hat, kann man damit leben. Und mit der Freeware-Version, Light- oder auch Non-Profit-Version kann man schon einiges machen. Früher oder später wirst eh nicht darum herumkommen, auch Platinen zu machen, und dann kannst Du schon auf eine Basis von Schaltplänen zurückgreifen, die Du vorher nur z. B. auf Lochraster aufgebaut hast und brav vorher wenigstens einen Schaltplan davon gezeichnet hast.
** Die bereits erwähnte '''[http://www.cadence.com/products/orcad/downloads/orcad_demo/index.aspx OrCAD PCB Demo-CD]''' enthält eine Demo-Version von '''OrCADE Capture'''.
** Das schon erwähnte '''[http://www.geda.seul.org/tools/gschem/index.html gschem]''' aus der gEDA-Sammlung.
** Die freie Software '''[http://www.lis.inpg.fr/realise_au_lis/kicad/ KiCad]''' für Linux und Windows (siehe auch den Artikel [[KiCAD]]).
:Siehe den Artikel [[Schaltplaneditoren]] für weitere Informationen zu Schaltplaneditoren.

* Ein '''Layout-Editor''' ist nützlich, um den Schaltplan dann in eine Vorlage zum Selbstätzen umzusetzen oder die Platine als Datei zum Leiterplattenhersteller zu senden.
** Das bereits erwähnte '''[http://www.cadsoft.de/ Eagle von Cadsoft]''' gilt auch hier als der Standard im Hobbybereich.
**'''[http://www.ibfriedrich.com TARGET 3001! ]''' vom Ing.-Büro Friedrich ist eine komplette Software vom Schaltplan bis zum Layout, inkl. Simulation oder Isolationsfräsen. Die kostenlose [http://www.ibfriedrich.com/download.htm Discover-Version] geht bis 250 Pins. Einen einfachen Einstieg findet man '''[http://ibfriedrich.dyndns.org/wiki/ibfwikide/index.php?title=Kurzeinführung2 hier]'''.
** In der gEDA-Sammlung für Linux findet man '''[http://www.geda.seul.org/tools/pcb/index.html PCB]''', das allerdings noch Ecken und Kanten hat.
** Das bereits erwähnte '''[http://www.lis.inpg.fr/realise_au_lis/kicad/ KiCad]''' ermöglicht ebenfalls die Erstellung von Platinen-Layouts.

* Zum Aufbau auf Platinen mit '''Lochraster''' oder '''Lochstreifen''' gibt es die Tools
** [http://www.geocities.com/stripboarddesigner/ Stripboard Designer] (Shareware)
** [http://veecad.com/ VeeCAD] Stripboard Layout Editor
** [http://www.abacom-online.de/html/lochmaster.html Lochmaster] (ca. 40€)
** [http://blackboard.serverpool.org/Home/News.html Blackboard], das kommt [http://www.mikrocontroller.net/topic/open-source-lochraster-layout hier aus dem Forum], ist opensource und kostenlos. Auf [http://www.sebulli.com/BlackBoard/index.html Sebulli] gibt es ein paar ergänzende Bauteil-Libraries.
** mit einem Zeichenprogramm ([http://www.mikrocontroller.net/topic/112889 Forenbeitrag])
** Alternativ kann man mit (Kästchen-)Papier und Stift entwerfen...

==Baukästen==
Elektronikbaukästen bieten die Möglichkeit, das was man gelernt hat, gleich praktisch anzuwenden. Sie beinhalten die notwendigen Bauteile und sind oft didaktisch sinnvoll aufgebaut.

*'''Kosmos XN'''
** '''XN1000''' Bereits für Kinder geeignet. Prof. Armstrong und der kleine Roboter Robert führen spielend in die Welt der Elektronik ein.
** '''XN2000''' Die Erweiterung.
** '''XN3000''' Nicht mehr auf Kinder, sondern auf Jugendliche ausgerichtet. Relativ anspruchsvoll, aber verständlich.
** ''Nachteil:'' relativ teuer
*'''Busch-Elektronik-Kästen (Conrad)'''
**''Nachteil:'' Weil die Bauteile auf kleinen Platten befestigt sind, kann man mit ihnen keine eigenen Schaltungen aufbauen.
*'''Polytronic A B C ... (ex. DDR)''' aber nicht um jeden Preis im Kaufhaus kaufen - also Vorstufe zum Steckbrett
*'''Lernpaket Elektronik 2006 (amazon)''' Sehr gut geeignet, da echte ungesockelte Bauelemente die überall nachgekauft werden können.
**''Nachteil:'' Steckbrett wird schnell "zu klein"
*'''Lernpaket Elektronik mit ICs (Franzis)''' Ausgezeichnetes Lernpaket für Theorie und Praxis: '''[http://www.franzis.de/elo-das-magazin/literatur-und-software/experimente/lernpaket-elektronik-mit-ics Lernpaket Elektronik mit ICs]'''
**''Besonders schön:'' Es liegt ein großes Breadboard bei
**''Und dazu:'' Es werden nur kommerzielle Bauelemente eingesetzt, alles ist also nachbestellbar, Erweiterungen sind kein Problem.
*'''Lernpaket Sensortechnik (Franzis)''' Hervorragendes Lernpaket für angewandte Sensorelektronik: '''[http://www.elo-web.de/elektronik-lernpakete/mechatronik/elektrotechnik-industrielle-elektronik/lernpaket-sensortechnik Lernpaket Sensortechnik]'''
**''Inhalt:'' Alle gängigen Sensoren, Opto-, Thermo-, Hall-Sensor etc.
**''Weiterhin:'' Interessante ICs: LM386, 555, Bargraph-Treiber, LEDs etc. etc.
*'''NerdKit''' Steckbrett, AVR Microcontroller, LCD Screen, Temperatursensor, Piezo-Summer und weitere Bauteile. Interessante Projekte finden sich auf der '''[http://www.nerdkits.com/ Nerdkits Webseite]'''. ''Die Dokumentation ist englischsprachig.''
*'''Einsteigerbox Elektronik I:''' '''[http://www.ehajo.de/starterkits/einsteigerbox-elektronik-1.html/eHaJo Link: Einsteigerbox von EhaJo]'''
**''Kleines aber gut durchdachtes Einsteigerpaket''
**''Inklusive hochwertigem Breadboard, Transistoren, Widerständen, Kondensatoren, Batterieclip etc.''

== Sinnvolles Wissen ==
* Es schadet nicht, wenn man das [http://de.wikipedia.org/wiki/Ohmsches_Gesetz ohmsche Gesetz] und die [http://de.wikipedia.org/wiki/Kirchhoffsche_Regeln kirchhoffschen Regeln] kennt.
* [http://www.electronic-weblessons.de Electronic Weblessons] - Multimedial aufbereitetes Basiswissen zum Thema Elektronik in Form von WebLessons von Wis-Con (Multimedia, Sprache Deutsch)
* http://www.tldp.org/HOWTO/html_single/Coffee/ ;)

== Was tun, wenn es brennt? ==

Hier ist eine Liste der üblichen Anfängerfragen. Bitte überprüfe doch all diese Punkte. Falls Du zu einem der Punkte detaillierte Fragen hast, kannst Du Dich auch an die Experten im Forum wenden. Viel Glück bei der Suche!
*'''Anschlüsse vergessen''' Bevor Du die Schaltung das erste Mal an die Spannungsquelle hängst, überprüfe doch folgendes:
**'''VCC''' und '''GND''' Wurden die Bauteile mit der Versorgungsspannung verbunden? In aller Eile vergisst man dies leicht.
**'''Abblockkondensatoren''' Für sichere Funktion die Abblockkondensatoren (oft 100nF) nahe an den Pins anschließen. Sie sollen Störungen abfangen.
*'''Bauteile richtig herum eingesetzt?'''
*'''Wackelkontakt''' am Breadboard. Die Steckbretter haben leider häufig die Eigenschaft, dass die Kontakte nicht perfekt sind.
*'''korrekte Werte''' Gelegentlich liest man von Newbies, die etwas von 100µF am Quarz schreiben und sich ernsthaft wundern, weshalb nichts schwingt...

===Probleme beim Mikrocontroller===
*'''Quarz schwingt nicht'''. Ein Anzeichen hierfür ist, wenn die Spannung zwischen XTAL1 und GND nicht ungefähr 1/2 VCC beträgt.
*'''Steckkontakte''' sind nicht ok - Steckbretter haben manchmal schlechte Kontakte. Aus diesem Grund ist es sinnvoll, Mikrocontroller mit Sockel auf eine Platine zu löten.
*'''falsche Kondensatoren'''
*'''Bauteil beschädigt'''


==Bezugsquellen==
*'''http://www.csd-electronics.de''' Günstiger Anbieter, führt vieles, was man als Einsteiger braucht, dazu oft günstig. Versandkosten 3,85 bis 4,85 €.
*'''http://www.reichelt.de''' Mittel-günstiger Anbieter, führt leider nicht alles, was das Elektronikerherz begehrt. Der Grund hierfür ist, dass er sich hauptsächlich auf Mainstreamprodukte stützt, die einen großen Absatz finden. Nur so ist der günstige Preis möglich. Mindestbestellwert und Versandkosten nach Deutschland und Österreich sind gewichtabhängig, ab 5,60 oder 11,20 €.
* '''http://www.pollin.de''' Diverse Restposten, sehr günstige Preise aber keine große Auswahl an Standardbauteilen.
* '''http://www.conrad.de''' Filialen in vielen Städten, oft relativ hohe Preise - aber nicht immer. Vergleichen lohnt.
* '''http://www.ELV.de''' Versandkosten 6,95 € (inklusive Zustellgebühr)
* '''http://www.segor.de''' Hat manchmal Teile, die man bei Reichelt, Conrad nicht bekommt. Versandkosten 6,00 € (bei Kleinmengen jedoch 10,00 €)
* '''http://www.digikey.de''' Recht hohe Versandkosten dafür aber fast alles erhältlich auch in grossen Mengen.
* '''http://www.guloshop.de''' nur wenige Artikel, aber fast immer der günstigste Anbieter bei AVR-Standard-Mikrocontrollern. Versandkosten 2,40 bis 4,80 €.
* '''http://www.batterie24.de/Lithium-Batterien.html''' Für Schaltungen/Stromversorgung hochwertige Lithium-Batterien von Saft & Ultralife sowie FGS-Bleiakkus zu günstigen Preisen (z.B. 1 x Saft Lithium-Batterie LS14500 3,6V Mignon AA für 4,40 €).

Der Artikel [[Elektronikversender]] zählt viele weitere Versender auf. Doch sollte man darauf achten, dass gerade sogenannte Distributoren in Deutschland normalerweise nicht an Privatleute verkaufen wollen (eine merkwürdige deutsche Spezialität) und mit Privatleuten auch mal sehr ruppig umgehen. Eine Ausnahme machen einige Distributoren für Studenten, da man sich so erhofft, frühzeitig Kontakt zu späteren gewerblichen Kunden zu bekommen. Eine andere Ausnahme sind normale Versender, die sich zusätzlich als Distributoren betätigen.