Hilfreich zu wissen
Grundlagen zum Verständnis „digitaler Welten“

Ein Mikrocontroller kann nur mit zwei Zuständen arbeiten: 0 und 1 (Null und Eins).
Für diese zwei möglichen Zustände werden häufig synonyme Begriffe verwendet: 

0

L

low

nein

falsch

off

aus

GND

-

1

H

high

ja

wahr

on

an

+5V

+

Welche dieser Begriffe verwendet wird hängt meist vom Thema ab, einige Beispiele:

0

1

Im Dualssystem (Mathematik, Computer)

 

L

H

Elektronik (logische Ein-, Ausgänge von ICs)

low

high

 

nein

ja

Logik (Boolsche Algebra in der Mathematik, Flussdiagramme)

falsch

wahr

 

off

on

Elektronik (DIP- oder Kodier-Schalter)

Schaltungstechnik, und vieles mehr.

aus

an

 

GND

+5V

Elektronik, Schaltpläne, etc.

(Ein-/Ausgänge von Kontrollern)

-

+

All dies bezeichnet im Grund Dasselbe: eine digitale Logik
(verdeutscht „Zweier-Logik“, da es nur zwei Zustände gibt).
 

Zu Anbeginn sind wir mit dem Dezimal-System vertraut gemacht worden und tun uns deshalb mit anderen Zahlensystemen etwas schwer. Aber sehen wir uns einmal ganz kurz andere Zahlensysteme an und vergleichen diese mit dem uns vertrauten Dezimalsystem:

Ursprünglich zählte der Mensch von EINS bis ZEHN (wohl weil er zehn Finger besitzt), die Null spielte noch keine Rolle (was soll man auch mit Nichts anfangen?).

Die Mathematiker verwenden jedoch lieber Ziffern, statt Finger, und führten zehn Ziffern ein:
 

0

1

2

3

4

5

6

7

8

9

Möchte man nun weiter als nur bis 9 zählen, benötigt man die Null.

Schreiben wir die Tabelle einmal etwas anders angeordnet hin:

Das Dezimal-System

Zehner

Einer

 

0

 

1

 

2

 

3

 

4

 

5

 

6

 

7

 

8

 

9

1

0

1

1

1

2

……

…..

……

…..

2

0

2

1

und so weiter, bis:

9

9

Bei 99 ist Schluss. Für 100 benötigen wir eine weitere Spalte (in der Elektronik eine weitere Speicherstelle).
Wählen wir einmal die gleiche Darstellung für das Dual-System:

 

0

 

1

1

0

1

1

Bereits nach Vier Zeilen ist Schluss. Um hier dual weiter zu zählen benötigten wir bereits jetzt eine weitere Spalte.

Schreiben wir einmal neben der Dezimal-System-Tabelle eine Duals-System-Tabelle und zählen nur mal bis 15
(also von 0 bis 15, was 16 Zeilen entspricht):

Dezimal-System

 

Dual-System

 

Umrechnung Dual=>Dezimal

101

100

100=1   101=10

 

23

22

21

20

 

20=1 + 21=2 + 22=4 + 23=8 = 15

 

0

0*101+0*1000

 

0

0

0

0

 

0*23+0*22+0*21+0*20=0

 

1

0*101+1*1001

 

0

0

0

1

 

0*23+0*22+0*21+1*20=1

 

2

0*101+2*1002

 

0

0

1

0

 

0*23+0*22+1*21+0*20=2

 

3

0*101+3*1003

 

0

0

1

1

 

0*23+0*22+1*21+1*20=3

 

4

0*101+4*1004

 

0

1

0

0

 

0*23+1*22+0*21+0*20=4

 

5

0*101+5*1005

 

0

1

0

1

 

0*23+1*22+0*21+1*20=5

 

6

0*101+6*1006

 

0

1

1

0

 

0*23+1*22+1*21+0*20=6

 

7

0*101+7*1007

 

0

1

1

1

 

0*23+1*22+1*21+1*20=7

 

8

0*101+8*1008

 

1

0

0

0

 

1*23+0*22+0*21+0*20=8

 

9

0*101+9*1009

 

1

0

0

1

 

1*23+0*22+0*21+1*20=9

1

0

1*101+0*100=10

 

1

0

1

0

 

1*23+0*22+1*21+0*20=10

1

1

1*101+1*100=11

 

1

0

1

1

 

1*23+0*22+1*21+1*20=11

1

2

1*101+2*100=12

 

1

1

0

0

 

1*23+1*22+0*21+0*20=12

1

3

1*101+3*100=13

 

1

1

0

1

 

1*23+1*22+0*21+1*20=13

1

4

1*101+4*100=14

 

1

1

1

0

 

1*23+1*22+1*21+0*20=14

1

5

1*101+5*100=15

 

1

1

1

1

 

1*23+1*22+1*21+1*20=15

Jede Zahl, egal aus welchem Zahlensystem, lässt sich in ihre Bestandteile zerlegen, Im uns vertrauten Zehnersystem beispielsweise
die Zahl 13 in Zehner (1) und Einer (3). Also 1 Zehner und 3 Einer. Drücken wir das etwas mathematischer aus:

Das Zehner System besitzt die Basis 10. Die einzelnen Stellen schreiben wir so:

Einer:        100 =     1

Zehner:     101 =   10

Hunderter: 102 = 100

und so weiter

 

Somit lässt sich unsere Beispielszahl 13 zerlegen in 1 mal 10 plus 3 mal 1, oder nun wirklich mathematisch formuliert:

1*101 + 3*100 = 13

Nach demselben Prinzip lässt sich auch jedes andere Zahlensystem zerlegen:

Das Dual System besitzt die Basis 2. Die einzelnen Stellen schreiben wir so:

1.Stelle:     20 = 1

2. Stelle:    21 = 2

3. Stelle:    22 = 4

4. Stelle:    23 = 8

und so weiter

 

Somit lässt sich unsere Beispielszahl 13 zerlegen in 1 mal 8 plus 1 mal 4 plus 0 mal 2 plus 1 mal 1, oder nun wirklich mathematisch formuliert:

1*23 + 1*22 + 0*21 + 1*20 = 13

(Im Grunde simpler als im Zehnersystem;

es gibt steht nur 1 oder 0 mal 2 hoch x)

Anmerkung: die Hochzahl gibt an wie oft die Basis mit sich selbst zu multiplizieren ist.

Zum Beispiel 23 = 2*2*2 = 8. Beachte: jede Zahl hoch Null ist 1, also 20=1

Fügen wir nun noch ein Beispiel der Addition in beiden Zahlensystemen an und vergleichen wir:

 

23

22

21

20

Dez.

In Spalte 20 addieren wir 1+0=1.

In Spalte 21 addieren wir 1+1=0 mit Übertrag 1 in Spalte 22

In Spalte 22 addieren wir 0+Übertrag 1=1

In Spalte 23 addieren wir 1+0=1

 

1

0

1

1

11

+

0

0

1

0

  2

=

1

1

0

1

13

Irritiert uns im Dualsystem „In Spalte 21 addieren wir 1+1=0 mit Übertrag 1 in Spalte 22“?

Nein, das das kennen wir auch aus unserem Dezimalsystem:

 

101

100

 

 

In Spalte 100 addieren wir 9+1=0 mit Übertrag 1 in Spalte 101

In Spalte 101 addieren wir 0+Übertrag 1=1

So erhalten wir das Ergebnis 10

 

0

9

  9

+

0

1

  1

=

1

0

10

Wir haben also gelernt:

Dezimal-System

Dual-System

Basis = 10

Basis = 2

10x, wobei x die Zehner-Stelle angibt

2x, wobei x die Dual-Stelle angibt

es gibt 10 Ziffern {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

es gibt nur 2 Elemente {0, 1}

Addition: 9 + 1 = 0 plus Übertrag 1

Addition: 1 + 1 = 0 plus Übertrag 1

Es gibt noch mehr Zahlensysteme. Eines wollen wir noch anfügen, da es eine wesentliche Rolle in der digitalen Welt spielt:

Das Hexadezimal-System

Basis = 16

16x, wobei x die Hex-Stelle angibt

es gibt 16 Elemente {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F} = Wertemenge

im Dezimalsystem: A=10, B=11, C=12, D=13, E=14, F=15

Addition: F + 1 = 0 plus Übertrag 1

 

Dezimal-System

 

Hexl-System

 

Umrechnung Hex=>Dezimal

101

100

100=1   101=10

 

162

161

160

 

160=1 + 161=16 + 162=256 = 273

 

0

0*101+0*1000

 

0

0

0

 

0*161+ 0*1600

 

1

0*101+1*1001

 

0

0

1

 

0*161+ 1*1601

 

2

0*101+2*1002

 

0

0

2

 

0*161+ 2*1602

 

3

0*101+3*1003

 

0

0

3

 

0*161+ 3*1603

 

4

0*101+4*1004

 

0

0

4

 

0*161+ 4*1604

 

5

0*101+5*1005

 

0

0

5

 

0*161+ 5*1605

 

6

0*101+6*1006

 

0

0

6

 

0*161+ 6*1606

 

7

0*101+7*1007

 

0

0

7

 

0*161+ 7*1607

 

8

0*101+8*1008

 

0

0

8

 

0*161+ 8*1608

 

9

0*101+9*1009

 

0

0

9

 

0*161+ 9*1609

1

0

1*101+0*100=10

 

0

0

A

 

0*161+ A*160=10  mit A=10DEZ

1

1

1*101+1*100=11

 

0

0

B

 

0*161+ B*160=11  mit B=11 DEZ

1

2

1*101+2*100=12

 

0

0

C

 

0*161+ C*160=12  mit C=12 DEZ

1

3

1*101+3*100=13

 

0

0

D

 

0*161+ D*160=13  mit D=13 DEZ

1

4

1*101+4*100=14

 

0

0

E

 

0*161+.E*160=14  mit E=14 DEZ

1

5

1*101+5*100=15

 

0

0

F

 

0*161+ F*160=15  mit F=15 DEZ

1

5

1*101+6*100=16

 

0

1

0

 

1*161+  0*160=16

1

5

1*101+7*100=17

 

0

1

1

 

1*161+  1*160=17

1

5

1*101+8*100=18

 

0

1

2

 

1*161+  2*160=18

1

5

1*101+9*100=19

 

0

1

3

 

1*161+  3*160=19

1

5

2*101+0*100=20

 

0

1

4

 

1*161+  4*160=20

1

5

2*101+1*100=21

 

0

1

5

 

1*161+  5*160=21

 

……usw………

 

….

….

….

 

….(damit die Tabelle nicht zu langweilig wird).….

 

 

3*101+0*100=30

 

0

1

E

 

1*161+E*160=16+14=30  mit E=14 DEZ

 

 

3*101+1*100=31

 

0

1

F

 

1*161+F*160=16+15=31  mit F=15 DEZ

 

 

3*101+2*100=32

 

0

2

0

 

2*161+0*160=32 + 0=32

 

 

3*101+3*100=32

 

0

2

1

 

2*161+1*160=32 + 1=33

 

……usw………

 

….

….

….

 

….(damit die Tabelle nicht zu langweilig wird).….

 

 

4095

 

1

1

1

 

F*162+F*161+F*160=4095  mit F=15 DEZ

Mit einer 3-stelligen Hex-Zahl können wir also dezimal 4-stellig bis 4095 zählen:

F*162+F*161+F*160 = 15*256 + 15*16 + 15*1 = 3840 + 240 + 15 = 4095

Wollten wir noch weiter zählen würden wir eine weitere „Hex-Stelle“ 164 benötigen.

 

Warum uns dies alles vermutlich nervt,
                                                    und wir es dennoch verstehen müssen:
                                                                     Ein analog denkendes Gehirn trifft auf eine digital arbeitende Maschine

Der obige Satz beinhaltet bereits eine fundamentale Diskrepanz:

analog <=> digital

Denken <=> abarbeiten

Gehirn <=> Maschine

 

Man kann sagen, das menschliche Gehirn arbeitet analog. Nehmen wir zum Beispiel das Empfinden von Helligkeit. Unser Auge empfängt Licht und wir drücken Helligkeitsempfinden aus in grell, hell, trüb, dämmrig, dunkel, schwarz wie die Nacht, usw. Zugegeben, das sind alles keine exakten und objektiven Beschreibungen von Helligkeit und jeder Mensch wird Helligkeitsunterschiede mehr oder weniger unterschiedlich empfinden und beschreiben. Aber, das menschliche Gehirn erfasst Helligkeit in Bruchteilen von Sekunden, ohne groß darüber nachdenken zu müssen, oder gar erst Berechnungen darüber anstellen zu müssen. Eine geniale Erfindung der Natur!
 
Der Blechtrottel –Verzeihung unser Mikrokontroller – empfängt Licht mittels eines lichtempfindlichen Sensors. Jetzt fängt er erst einmal an zu rechnen. Dass heißt er muss erst einmal einen ihm zur Verfügung stehen Bereich von „ganz hell“ bis „ganz dunkel“ in endliche Intervalle aufteilen und dann den aktuellen Messwert in ein entsprechendes Intervall einordnen. Nun ist unser Mikrokontroller zudem noch so beschränkt, dass er nur mit Bits (1 oder 0) umgehen kann; er arbeitet also digital! Eine prinzipielle Zuordnung könnte nun so aussehen:

 

 

Speicher einer Variablen

 

27

26

25

24

23

22

21

20

Ergebnis

0

0

0

0

0

0

0

0

= ganz dunkel

0

0

0

0

0

1

0

0

= dämmrig

0

0

0

1

0

0

0

0

= trüb

0

10

0

0

0

0

0

0

= hell

……………….

1

0

0

0

0

0

0

0

= grell

 

 Wir müssen also Kenntnis davon haben wie unser Mikrokontroller arbeitet, um ihm das beibringen zu können was wir wollen.

Dazu ist das Wissen aus den vorstehenden Seiten von großem Wert!

Die beispielhafte Tabelle ist sehr einfach gehalten und gibt die genanten Intervalle nicht wirklich wieder:

„dämmrig“ kann nicht auf nur einen Messwert von „00000100“ beschränkt werden!

 

Anmerkung:

Das Aufteilen eines Messbereichs in Intervalle haben wir in einem Beispielprogramm bereits kennen gelernt:
PGM_01 auf Seite 10, dort die Programmzeile:

Spannung=Spannung/1024*5; // Eingangswert normiert auf den Bereich 0 bis 5 Volt; Einheit [V]!

 

Spannung=Spannung/1024*5;

 

Der vom AD-Wandler erzeugte Wert wird hier in die Einheit Volt gewandelt und der Variablen „Spannung“ wieder übergeben.

In Worten: Spannung ergibt sich aus Spannung durch 1024 mal 5

Analoge Signale kann ein Mikrokontroller nur digital verarbeiten! Der ARDUINO wird mit einer Spannung von 5 V betrieben und nimmt diese als Referenzspannung. Ein analoges Signal von bis zu 5 V durchläuft einen Analog-Digital-Wandler, welcher den Spannungsbereich von 0 bis 5 Volt in 1024 Bereiche aufteilt (1024 dezimal = 210, das sind 10 Bit, also die Auflösung; 10 Bit AD-Wandler).

5V/1024=0,00488V ist damit die maximal erreichbare Auflösung.

 

Ich denke, nun verstehen wir die Beschreibung im gelben Kasten von Grund auf. Was dort das Poti mit Spannungsbereich von 0 bis 5 Volt ist, ist im oberen Beispiel ein Helligkeitssensor von Dunkel bis Hell.

Die Messgrößenaufteilung für einen Mikrokontroller folgt dem gleichen Prinzip.

 

Bit, Byte, & Co, wichtige Begriffserklärungen

Ein Bit stellt die kleinste Einheit dar.

Eine einzige Speicherstelle im Mikrokontroller kann hier die Information 0 oder 1 speichern.

Ein Byte besteht aus 8 Bit.

27

26

25

24

23

22

21

20

Ein Byte kann somit Dezimalzahlen von

Null:

0

0

0

0

0

0

0

0

bis 27+26+25+24+23+22+1+20 = 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255 darstellen:

1

1

1

1

1

1

1

1

Ein Byte kann also 256 verschiedene Zustände aufweisen (0 bis 255, wenn man es dezimal mag);

es muss sich hier nicht immer um Dezimalzahlen handeln; es kann sich beispielsweise auch um 256 Schalter handeln, von denen welche an- oder ausgeschaltet sind.

Ein Halbbyte (englisch: Nibble) besteht aus einem halben Byte, also aus 4 Bits.

 

 

 

 

MSB und LSB

MSB  höherwertiges      Byte (most significant Byte)

LSB   niederwertiges     Byte (lowest significant Byte)

27

26

25

24

23

22

21

20

MSB

 

 

 

 

 

 

LSB

Einheiten, (Größenangaben beispielsweise Speicher)

1 Byte

=

1 Bit

1 KB = 1 Kilobyte     = 103 B

=

1.024 Byte = 210 Byte

1 MB = 1 Megabyte = 106 B

=

1.024 KB   = 210 KB

1 GB = 1 Gigabyte   = 109 B

=

1.024 MB   = 210 MB

1 TB = 1 Terabyte   = 1012 B

=

1.024 GB   = 210 GB

Anmerkung:

Meistens findet man Angaben in KB, MB, GB. Der linke Teil der obigen Tabelle gibt dies wieder, ist aber nicht wirklich korrekt. Warum?

1 Byte besteht aus 8 Bit.

Teilen wir einmal 1 KB, also 1000 [Byte] durch 8 [Bit], dann erhalten wir die Zahl 125.

Betrachten wir den rechten Teil der obigen Tabelle:

210 Byte sind exakt 1.024 Byte. Teilen wir 1.024 [Byte] durch 8 [Bit], dann erhalten wir die Zahl 128! Dies ist nun wirklich korrekt! (denn 27=128 und es existiert keine ganze Zahl n mit der 2n 125 ergibt!!!).

Man kann sagen, der linke Teil der Tabelle gibt „grobe“ Größen an, der rechte Teil der Tabelle die „wahren“ Größen.

Dies ist übrigens auch der Grund warum beispielsweise Speichergrößenangaben von Festplatten nie wirklich exakt angegeben werden.



 

zurück zu ARDUINO Grundlagen