Grundlagen · 11 Min. Lesezeit

Binärsystem und Hexadezimal: Bitoperationen am Arduino erklärt

Binärsystem, Hexadezimal und Dezimal umrechnen, Bit und Byte, 0b und 0x am Arduino, &, |, ^, ~, <<, >> mit bitRead sowie Beispiele für 74HC595 und Register.

Das Binärsystem (Dualsystem) verwendet nur die Ziffern 0 und 1 und ist die Grundlage der gesamten Digitalelektronik. Jeder Pin, jedes Register und jedes Byte im Speicher eines Arduino ist in Wahrheit eine Binärzahl aus Schaltern, die an oder aus sind: 1 bedeutet, dass ein Pin HIGH ist, 0, dass er LOW ist. Ausdrücke wie 0b10110101, 0xB5 oder PORTB |= (1 << 5) wirken im Code vielleicht abschreckend, doch sobald du Binär- und Hexadezimalsystem verstanden hast, lassen sie sich alle auf ein paar einfache Regeln zurückführen.

In dieser Anleitung siehst du zuerst, wie du Dezimal-, Binär- und Hexadezimalzahlen von Hand ineinander umrechnest, was Bit, Nibble und Byte sind und wie negative Zahlen im Speicher stehen. Danach lernst du, Zahlen am Arduino mit 0b und 0x zu schreiben, ein einzelnes Bit mit AND, OR, XOR, NOT und Schiebeoperationen zu lesen und zu ändern und die Funktionen bitRead, bitWrite und bitSet zu nutzen. Zum Schluss bereitest du Bytes für eine 7-Segment-Anzeige und einen 74HC595 vor und schreibst auf Uno, ESP32 und Pico direkt in Register.

Was ist ein Zahlensystem? Dezimal, binär und hexadezimal

Im Dezimalsystem, das wir täglich nutzen, gibt es 10 Ziffern, und jede Stelle ist 10-mal so viel wert wie die vorherige: 181 ist 1×100 + 8×10 + 1×1. Das Binärsystem hat nur zwei Ziffern, und jede Stelle ist doppelt so viel wert wie die vorherige; von rechts nach links lauten die Stellenwerte 1, 2, 4, 8, 16, 32, 64, 128. Das Hexadezimalsystem (kurz Hex) hat 16 Ziffern: Nach 0–9 folgen A=10, B=11, C=12, D=13, E=14, F=15. Hex ist in der Elektronik so beliebt, weil jede Hexziffer genau 4 Bit entspricht; es ist die praktischste Art, lange Binärzahlen kurz und lesbar zu schreiben.

DezimalBinärHexDezimalBinärHex
000000810008
100011910019
200102101010A
300113111011B
401004121100C
501015131101D
601106141110E
701117151111F

Umrechnen: zwischen Dezimal, Binär und Hex

Um dezimal in binär umzurechnen, teilst du die Zahl immer wieder durch 2 und notierst die Reste; liest du die Reste von unten nach oben, ergibt sich die Binärzahl. Für 181: 181/2 = 90 Rest 1, 90/2 = 45 Rest 0, 45/2 = 22 Rest 1, 22/2 = 11 Rest 0, 11/2 = 5 Rest 1, 5/2 = 2 Rest 1, 2/2 = 1 Rest 0, 1/2 = 0 Rest 1. Von unten nach oben gelesen ergibt das 10110101. Die Umrechnung binär in dezimal ist einfacher: Du addierst die Stellenwerte der Stellen, an denen eine 1 steht. 10110101 = 128 + 32 + 16 + 4 + 1 = 181.

Stellenwert1286432168421
10110101 (181)10110101
00001100 (12)00001100
11111111 (255)11111111

Um binär in hex umzurechnen, teilst du die Bits von rechts beginnend in Vierergruppen und ersetzt jede Gruppe durch ihre Hexziffer aus der Tabelle: 1011 0101 → B 5 → 0xB5. Umgekehrt geht es genauso leicht: 0x3C → 0011 1100. Für hex in dezimal multiplizierst du jede Ziffer mit einer Potenz von 16: 0xB5 = 11×16 + 5 = 181, 0x3FF = 3×256 + 15×16 + 15 = 1023. Das letzte Beispiel kommt dir bekannt vor: Die Obergrenze des 10-Bit-Werts von analogRead am Uno ist 1023, also zehn Einsen. Den Zusammenhang zwischen Analogwert und Bitzahl findest du im ADC-Artikel.

Der Programmiermodus des Taschenrechners auf deinem Computer und der serielle Monitor des Arduino sind die schnellsten Wege, Umrechnungen zu prüfen. Serial.println(181, BIN) gibt 10110101 aus, Serial.println(181, HEX) B5. Wenn du die Umrechnung aber ein paarmal von Hand machst, fällt dir das Lesen von Registertabellen und Datenblättern viel leichter.

Bit, Nibble, Byte und Wertebereiche

Eine einzelne Binärziffer heißt Bit. 4 Bit bilden ein Nibble, also eine Hexziffer; 8 Bit ergeben ein Byte, das mit zwei Hexziffern geschrieben wird. Das rechte Bit eines Bytes ist das niederwertigste Bit (LSB, Bit 0), das linke das höchstwertige (MSB, Bit 7). Bitnummern beginnen immer bei 0, daher sind die Bits einer 8-Bit-Zahl von 0 bis 7 nummeriert. Mit n Bit lassen sich 2ⁿ verschiedene Werte darstellen: 8 Bit sind 256, 10 Bit 1024 und 16 Bit 65536 verschiedene Werte.

GrößeArduino-TypBereich ohne VorzeichenBereich mit Vorzeichen
8 Bit (1 Byte)byte, uint8_t / int8_t0–255-128 bis 127
16 Bit (2 Byte)int am Uno, word, uint16_t0–65535-32768 bis 32767
32 Bit (4 Byte)long, uint32_t; int bei ESP32 und Pico0–4.294.967.295-2.147.483.648 bis 2.147.483.647

Negative Zahlen: Zweierkomplement

Mikrocontroller speichern negative Zahlen im Zweierkomplement: Ist bei einer vorzeichenbehafteten Zahl das linke Bit 1, ist die Zahl negativ. Um das Negative einer Zahl zu bilden, invertierst du alle Bits und addierst 1. 5 = 00000101; invertiert 11111010; plus 1 ergibt 11111011 = 0xFB, also -5. Dasselbe Bitmuster ist je nach Lesart eine andere Zahl: 0xFF ist als byte 255 und als int8_t -1. Deshalb ist es so wichtig, rohe Sensorbytes dem richtigen Typ zuzuweisen. Überschreitet eine Variable ihre Obergrenze, beginnt sie von vorn: bei byte ist 255 + 1 = 0, bei int am Uno 32767 + 1 = -32768; das nennt man Überlauf (Overflow).

Zahlen am Arduino mit 0b, 0x und B schreiben

Im Arduino-Code kannst du dieselbe Zahl auf drei Arten schreiben, für den Compiler macht das keinen Unterschied: 181 (dezimal), 0b10110101 (binär, seit C++14 Standard) und 0xB5 (hexadezimal). Arduino kennt außerdem die Form B10110101 aus älterem Code; das sind aber nur für 8-Bit-Werte definierte Konstanten, in neuem Code ist 0b besser. Welche Form du wählst, hängt von der Lesbarkeit ab: Binär ist am klarsten für LED-Muster und Registereinstellungen, Hex für Adressen und Farbcodes, dezimal für Messwerte.

C++ (Arduino IDE)
1// Aynı sayının üç yazımı ve Seri Monitör'de gösterimi
2// Three ways to write the same number and print it
3void binaryYaz(byte deger) {               // baştaki sıfırlarla 8 bit yaz / print 8 bits with leading zeros
4  for (int i = 7; i >= 0; i--) {
5    Serial.print(bitRead(deger, i));
6  }
7  Serial.println();
8}
9
10void setup() {
11  Serial.begin(9600);
12  byte a = 0b10110101;                       // ikilik / binary
13  byte b = 0xB5;                             // onaltılık / hex
14  byte c = 181;                              // onluk / decimal
15  Serial.println(a == b && b == c ? "Ucu de ayni / All equal" : "Farkli / Different");
16  Serial.println(c, BIN);                    // 10110101
17  Serial.println(c, HEX);                    // B5
18  Serial.println(c, DEC);                    // 181
19  Serial.println(12, BIN);                   // 1100 (baştaki sıfırlar yok / no leading zeros)
20  binaryYaz(12);                             // 00001100
21  Serial.println(010);                       // 8: baştaki 0 sekizlik demek / leading 0 means octal
22}
23
24void loop() {
25}
Eine führende Null macht in C++ aus einer Zahl eine Oktalzahl: 010 ist acht, nicht zehn, und 0255 ist 173. Schreibst du 08 oder 09, um Pinnummern oder Uhrzeiten auszurichten, meldet der Compiler einen Fehler; schreibst du 010, macht er ohne Warnung das Falsche. Setze vor Dezimalzahlen niemals eine Null.

Bitoperationen: &, |, ^, ~, << und >>

Bitoperationen vergleichen die Bits an derselben Stelle zweier Zahlen einzeln. AND (&) ergibt nur dann 1, wenn beide Bits 1 sind; OR (|) ergibt 1, wenn eines der Bits 1 ist; XOR (^) ergibt 1, wenn die Bits verschieden sind; NOT (~) invertiert alle Bits. Linksschieben (<<) schiebt die Bits nach links und füllt rechts mit 0 auf, wobei sich die Zahl mit jedem Schritt verdoppelt; Rechtsschieben (>>) schiebt sie nach rechts und halbiert die Zahl mit jedem Schritt. Das sind die Software-Gegenstücke der Logikgatter; ihre Wahrheitstabellen findest du im Artikel Logikgatter und im Logikgatter-Werkzeug. Die Tabelle zeigt die Ergebnisse für a = 0b11001010 (202) und b = 0b10101100 (172):

OperationWas macht sie?Ergebnis (binär)HexDezimal
a & bBits, die in beiden 1 sind100010000x88136
a | bBits, die in mindestens einer Zahl 1 sind111011100xEE238
a ^ bBits, die sich unterscheiden011001100x66102
~a (byte)Alle Bits invertiert001101010x3553
a << 1 (byte)Eine Stelle nach links, das linke Bit fällt weg100101000x94148
a >> 2Zwei Stellen nach rechts, die zwei rechten Bits fallen weg001100100x3250

Achte auf zwei Details in der Tabelle. Wird das Ergebnis von a << 1 in einem byte gespeichert, fällt das linke Bit heraus und es bleibt 148; in einem int ergibt dieselbe Operation 404, weil dort Platz für das überlaufende Bit ist. Bei ~a ist es ähnlich: als byte 53, als int berechnet werden auch die oberen Bits invertiert und das Ergebnis ist -203. Bei Bitoperationen musst du immer wissen, in welchem Typ das Ergebnis landet. Verwechsle außerdem nicht & und &&: Das erste arbeitet mit einzelnen Bits, das zweite prüft, ob zwei Bedingungen wahr sind.

Bitmasken: ein einzelnes Bit lesen, setzen und löschen

In echten Projekten werden Bitoperationen fast immer mit einer Maske verwendet. Eine Maske ist eine Zahl, in der nur die Bits 1 sind, die dich interessieren; meist wird sie mit (1 << n) gebildet: (1 << 3) = 0b00001000. Mit einer Maske gibt es vier Grundoperationen, und Arduino bietet für jede eine fertige Funktion. Der folgende Code speichert den Zustand von 8 LEDs in einem einzigen Byte statt in 8 bool-Variablen und gibt ihn auf die LEDs an D2–D9 aus:

ZielMit MaskeArduino-FunktionBeispiel (n = 3)
Bit auf 1 setzenx |= (1 << n);bitSet(x, n);00000000 → 00001000
Bit auf 0 löschenx &= ~(1 << n);bitClear(x, n);11111111 → 11110111
Bit umschaltenx ^= (1 << n);bitWrite(x, n, !bitRead(x, n));00001000 → 00000000
Bit lesen (prüfen)(x >> n) & 1bitRead(x, n);00001000 → 1
Bit auf einen Wert setzenx = (x & ~(1 << n)) | (v << n);bitWrite(x, n, v);v = 1 → 00001000
Wert von Bit n1 << nbit(n);bit(3) = 8
C++ (Arduino IDE)
1// 8 LED'in durumu tek bir baytta / the state of 8 LEDs in one byte
2const byte LED_PINLERI[8] = {2, 3, 4, 5, 6, 7, 8, 9};   // bit 0 -> D2 ... bit 7 -> D9
3byte durum = 0b00000000;
4
5void goster() {                                // baytı LED'lere yansıt / mirror the byte to the LEDs
6  for (byte i = 0; i < 8; i++) {
7    digitalWrite(LED_PINLERI[i], bitRead(durum, i));
8  }
9}
10
11void setup() {
12  Serial.begin(9600);
13  for (byte i = 0; i < 8; i++) pinMode(LED_PINLERI[i], OUTPUT);
14}
15
16void loop() {
17  durum |= (1 << 3);                           // bit 3'ü aç (D5) / set bit 3 (D5)
18  durum ^= 0b10000001;                         // bit 0 ve 7'yi tersle / toggle bits 0 and 7
19  goster();
20  Serial.println(durum, BIN);
21  delay(500);
22
23  durum &= ~(1 << 3);                          // bit 3'ü kapat / clear bit 3
24  bitWrite(durum, 5, !bitRead(durum, 5));      // bit 5'i tersle / toggle bit 5
25  goster();
26  if (durum & (1 << 5)) {                      // bit 5 açık mı? / is bit 5 set?
27    Serial.println(F("Bit 5 acik / Bit 5 is on"));
28  }
29  delay(500);
30}

Bytes für eine 7-Segment-Anzeige vorbereiten

Die acht Teile einer 7-Segment-Anzeige (Segmente a–g und der Punkt) passen genau in ein Byte. Ordnest du Bit 0 dem Segment a, Bit 6 dem Segment g und Bit 7 dem Dezimalpunkt (DP) zu, lässt sich jede Ziffer als eine einzige Zahl darstellen. Die 2 zum Beispiel besteht aus den Segmenten a, b, d, e und g: 1 + 2 + 8 + 16 + 64 = 91 = 0x5B. Bei Anzeigen mit gemeinsamer Anode leuchtet ein Segment bei LOW, deshalb invertierst du dieselbe Tabelle mit ~. Details zur Segmentverdrahtung findest du im Artikel 7-Segment-Anzeige.

ZifferLeuchtende SegmenteBinär (DP g f e d c b a)Gemeinsame KathodeGemeinsame Anode (~)
0a b c d e f001111110x3F0xC0
1b c000001100x060xF9
2a b d e g010110110x5B0xA4
3a b c d g010011110x4F0xB0
4b c f g011001100x660x99
5a c d f g011011010x6D0x92
6a c d e f g011111010x7D0x82
7a b c000001110x070xF8
8a b c d e f g011111110x7F0x80
9a b c d f g011011110x6F0x90

Das Byte mit einem 74HC595 an die Ausgänge schicken

Das Schieberegister 74HC595 verteilt ein Byte mit nur drei Pins auf acht Ausgänge und ist der Chip, an dem du Bitoperationen am deutlichsten siehst: Jedes Bit des gesendeten Bytes schaltet einen Ausgang ein oder aus. Mit MSBFIRST sendet shiftOut Bit 7 zuerst, das am Ende in Q7 landet, Bit 0 kommt in Q0. Verbindest du also Q0 mit Segment a, Q6 mit g und Q7 mit DP, funktioniert die obige Tabelle direkt. Alle Pins des Chips und das Hintereinanderschalten erklärt der Artikel 74HC595 Schieberegister.

VerbindungArduino UnoESP32Raspberry Pi Pico
DS (14), serielle DatenD11GPIO 23GP19
SH_CP (11), TaktD13GPIO 18GP18
ST_CP (12), LatchD10GPIO 5GP17
OE (13) / MR (10)GND / 5VGND / 3V3GND / 3V3(OUT)
Q0–Q6 / Q7Segmente a–g / DP, jeweils über WiderstandGleichGleich
C++ (Arduino IDE)
1// 74HC595 + ortak katotlu 7 segment: 0-9 sayacı / 0-9 counter
2const byte DATA_PIN = 11;    // DS (14)
3const byte CLOCK_PIN = 13;   // SH_CP (11)
4const byte LATCH_PIN = 10;   // ST_CP (12)
5const bool ORTAK_ANOT = false;   // ortak anotsa true / true for common anode
6
7// bit 0 = a ... bit 6 = g, bit 7 = DP
8const byte RAKAMLAR[10] = {0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F};
9
10void yaz595(byte desen) {
11  if (ORTAK_ANOT) desen = ~desen;                    // segmentler LOW ile yanar / segments light on LOW
12  digitalWrite(LATCH_PIN, LOW);
13  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, desen);    // bit 7 önce -> Q7 / bit 7 first -> Q7
14  digitalWrite(LATCH_PIN, HIGH);                     // çıkışlara aktar / copy to the outputs
15}
16
17void setup() {
18  pinMode(DATA_PIN, OUTPUT);
19  pinMode(CLOCK_PIN, OUTPUT);
20  pinMode(LATCH_PIN, OUTPUT);
21}
22
23void loop() {
24  for (byte i = 0; i < 10; i++) {
25    byte desen = RAKAMLAR[i];
26    if (i % 2 == 1) desen |= 0x80;                   // tek sayılarda noktayı yak / DP on odd digits
27    yaz595(desen);
28    delay(700);
29  }
30}

Direkt in Register schreiben: PORTB und DDRB

Beim ATmega328P des Uno sind die Pins in 8er-Gruppen, sogenannte Ports, aufgeteilt, und jeder Port hat drei Register: DDRx enthält die Richtung (1 = Ausgang), PORTx den Ausgangspegel und PINx den gelesenen Pegel. Die Pins D8–D13 liegen an Port B; D13 (die eingebaute LED) ist PB5, also Bit 5 von PORTB. pinMode und digitalWrite ändern genau diese Bits, rechnen aber zuerst die Pinnummer in einen Port um und brauchen deshalb einige Mikrosekunden. Direkt ins Register zu schreiben ist ein einziger Maschinenbefehl und dauert bei 16 MHz 2 Takte, also etwa 125 Nanosekunden. Außerdem kannst du so mehrere Pins desselben Ports exakt gleichzeitig ändern.

Uno-PinPort und BitUno-PinPort und Bit
D0–D7PD0–PD7 (PORTD)D8–D13PB0–PB5 (PORTB)
A0–A5PC0–PC5 (PORTC)D13 (eingebaute LED)PB5
C++ (Arduino IDE)
1// Uno: D13'ü register ile yönet / drive D13 through registers (ATmega328P)
2void setup() {
3  Serial.begin(9600);
4  DDRB |= (1 << DDB5);                // D13 çıkış (pinMode) / D13 as output
5  DDRD &= ~(1 << DDD2);               // D2 giriş / D2 as input
6  PORTD |= (1 << PORTD2);             // D2 dahili pull-up / internal pull-up on D2
7}
8
9void loop() {
10  PORTB |= (1 << PORTB5);             // D13 HIGH
11  delay(200);
12  PORTB &= ~(1 << PORTB5);            // D13 LOW
13  delay(200);
14  PINB = (1 << PINB5);                // PINx'e 1 yazmak pini tersler / writing 1 to PINx toggles
15  delay(200);
16  PINB = (1 << PINB5);
17  bool buton = !(PIND & (1 << PIND2));   // D2 GND'ye çekilince true / true when D2 is pulled to GND
18  Serial.println(buton ? "Basili / Pressed" : "Serbest / Released");
19}
Registercode ist boardspezifisch: Eine PORTB-Zeile, die am Uno funktioniert, steuert am Mega andere Pins, an ESP32 und Pico gar nichts und lässt sich dort nicht einmal kompilieren. Außerdem sind die Bits 0 und 1 von PORTD die Pins der seriellen Schnittstelle; eine Zeile wie PORTD = 0xFF, die den ganzen Port auf einmal schreibt, kann Serial stören. Ändere mit einer Maske nur die Bits, die dich interessieren, und nutze Registercode nur dort, wo Geschwindigkeit wirklich zählt.

Pins am ESP32 über Register steuern

Beim ESP32 werden die Pins über 32-Bit-Register gesteuert, und anders als beim AVR gibt es getrennte Set- und Clear-Register: Jedes 1-Bit, das du in GPIO_OUT_W1TS_REG (write 1 to set) schreibst, setzt den passenden Pin auf HIGH, jedes 1-Bit in GPIO_OUT_W1TC_REG (write 1 to clear) setzt ihn auf LOW, 0-Bits berühren keinen Pin. Da kein Lesen-Ändern-Schreiben nötig ist, ist das mit Interrupts und über beide Kerne hinweg sicher. Diese beiden Register decken nur GPIO 0–31 ab; ab 32 werden die GPIO_OUT1-Register verwendet.

C++ (Arduino IDE)
1// ESP32: GPIO 2'yi W1TS / W1TC register'larıyla yak-söndür
2// ESP32: blink GPIO 2 with the W1TS / W1TC registers
3#include "soc/gpio_reg.h"
4
5const int LED_PIN = 2;                         // birçok kartta dahili LED / onboard LED on many boards
6
7void setup() {
8  pinMode(LED_PIN, OUTPUT);                    // yön ve pin işlevi / direction and pin function
9}
10
11void loop() {
12  REG_WRITE(GPIO_OUT_W1TS_REG, 1UL << LED_PIN);   // HIGH (yalnız bu bit) / HIGH (only this bit)
13  delay(300);
14  REG_WRITE(GPIO_OUT_W1TC_REG, 1UL << LED_PIN);   // LOW
15  delay(300);
16}

Sensordaten zusammensetzen und zerlegen

I2C- und SPI-Sensoren senden 16-Bit-Messwerte meist als zwei einzelne Bytes: zuerst das High-Byte (MSB), dann das Low-Byte (LSB). Um sie zusammenzusetzen, schiebst du das High-Byte um 8 Stellen nach links und verknüpfst es per OR mit dem Low-Byte: int16_t roh = (msb << 8) | lsb;. Sendet ein Beschleunigungssensor zum Beispiel 0xFC und 0x18, ist das Ergebnis 0xFC18; als int16_t gelesen ist diese Zahl -1000, weil das linke Bit 1 ist. In die andere Richtung, um eine Zahl zu senden oder ins EEPROM zu schreiben, gibt es highByte(x) und lowByte(x), zum Zusammenfügen zweier Bytes word(high, low). Die I2C-Kommunikation selbst erklärt Was ist I2C?, einen Sensor mit zwei Byte langen Rohdaten zeigt der Artikel MPU6050.

AusdruckErgebnisErklärung
(0xFC << 8) | 0x180xFC18Setzt zwei Bytes zu einer 16-Bit-Zahl zusammen
(int16_t)0xFC18-1000Mit Vorzeichen gelesen negativ, weil das linke Bit 1 ist
highByte(1000)0x031000 = 0x03E8; das High-Byte
lowByte(1000)0xE8Das Low-Byte (232)
word(0x03, 0xE8)1000Setzt die beiden Bytes wieder zusammen
(zustand >> 4) & 0x0FOberes NibbleTrennt die oberen 4 Bits eines Bytes ab (z. B. ein Registerfeld)

Bits am Raspberry Pi Pico und in MicroPython

In MicroPython gelten dieselben Operatoren, dazu gibt es fertige Umrechnungsfunktionen: bin(), hex() und int(text, basis). Weil Python-Ganzzahlen beliebig groß werden, musst du die Ergebnisse von ~ und << mit & 0xFF maskieren, wenn sie in ein Byte passen sollen. Der RP2040 des Pico hat wie der ESP32 eigene Set-, Clear- und XOR-Register, in die du mit machine.mem32 direkt schreiben kannst. Der folgende Code lässt die eingebaute LED des Pico an GP25 über das XOR-Register blinken (beim Pico W hängt die eingebaute LED am WLAN-Chip, nimm dort eine externe LED).

MicroPython
1from machine import Pin, mem32
2import time
3
4x = 181
5print(bin(x), hex(x))                          # 0b10110101 0xb5
6print("{:08b}".format(12))                     # 00001100 (baştaki sıfırlarla / with leading zeros)
7print(int("10110101", 2), int("B5", 16))       # 181 181
8
9a, b = 0b11001010, 0b10101100
10print(a & b, a | b, a ^ b)                     # 136 238 102
11print(~a & 0xFF, (a << 1) & 0xFF, a >> 2)      # 53 148 50 (bayta sığdırılmış / masked to a byte)
12
13led = Pin(25, Pin.OUT)                         # pin işlevini ve yönü ayarla / set function and direction
14SIO_GPIO_OUT_XOR = 0xD000001C                  # RP2040 SIO: çıkışı tersle / toggle outputs
15for _ in range(6):
16    mem32[SIO_GPIO_OUT_XOR] = 1 << 25          # yalnız GP25'i tersle / toggle only GP25
17    time.sleep_ms(250)

Projektideen mit Bitoperationen

  • Binärzähler: Bau einen Zähler, der auf 8 LEDs von 0 bis 255 zählt, und sieh das Binärsystem mit eigenen Augen; ein Taster zählt hoch, der andere herunter.
  • Lauflicht im Knight-Rider-Stil: Schieb ein Byte mit << und >> hin und her, damit die LEDs pendeln; den Aufbau Schritt für Schritt zeigt der Artikel Knight Rider und Lauflicht.
  • Digitaluhr: Zeig die Uhrzeit auf einer vierstelligen 7-Segment-Anzeige und lass den Punkt der zweiten Stelle jede Sekunde mit der Maske 0x80 blinken.
  • Symbole auf der LED-Matrix: Zeichne jede Zeile einer 8×8-Matrix als Byte; entwirf Herzen, Pfeile oder Buchstaben mit 0b. Der Artikel MAX7219 LED-Matrix nutzt genau diese Methode.
  • Einstellungs-Flags: Speichere Ein/Aus-Einstellungen wie Ton an, helles Display oder Alarm gestellt in den Bits eines Bytes und schreib sie auf einmal ins EEPROM.
  • Adresswahl per DIP-Schalter: Lies einen 4-fach-DIP-Schalter und erhalte daraus eine Geräteadresse zwischen 0 und 15.

Häufige Fehler und ihre Lösungen

FehlerWas passiert?Richtig
if (x & 0x04 == 0)== wird zuerst ausgewertet, der Ausdruck wird zu x & 0 und ist immer falschif ((x & 0x04) == 0)
2 ^ 3 als Potenz^ ist XOR; 2 ^ 3 = 11 << 3 oder pow(2, 3)
1 << 15 oder 1 << 20 am UnoDas 16-Bit-int läuft über: -32768 oder 01UL << 20 (unsigned long)
Annehmen, Serial.println(x, BIN) gebe 8 Bit ausFührende Nullen fehlen: 12 → 11008 Bit mit bitRead in einer Schleife ausgeben
Führende 0 vor einer Zahl (010)Sie wird oktal: 010 = 8Führende Nullen bei Dezimalzahlen entfernen
Ergebnis von ~ in einem int verwendenAuch die oberen Bits werden invertiert: ~0x0F = -16Ergebnis einem byte zuweisen oder mit & 0xFF maskieren
&& statt & schreibenEs werden zwei Bedingungen verglichen, nicht BitsEinfaches & für Bits, && für Bedingungen
Bist du bei einer Bitoperation unsicher, gib das Ergebnis in drei Formen aus: Serial.println(x), Serial.println(x, BIN) und Serial.println(x, HEX). Denselben Wert dezimal, binär und hexadezimal zu sehen, zeigt sofort, ob Maske oder Verschiebung die erwarteten Bits getroffen hat.

Binär- und Hexadezimalzahlen und Bitoperationen wirken anfangs abstrakt, begegnen dir in der Elektronik aber täglich, vom Steuern einer LED-Reihe mit einem einzigen Byte bis zum Zusammensetzen von Sensordaten. Zusammen mit den Arduino-Programmiergrundlagen gelernt, machen sie deinen Code kürzer und schneller. In der BlueGrays-App findest du 7-Segment-Zähler, eine Digitaluhr, Lauflichter, Knight Rider und LED-Matrix-Projekte mit Schritt-für-Schritt-Schaltplänen und Code, der genau diese Bitoperationen nutzt.

Häufige Fragen

Was ist das Binärsystem?

Das Binärsystem verwendet nur die Ziffern 0 und 1, und jede Stelle ist doppelt so viel wert wie die vorherige. Von rechts nach links lauten die Stellenwerte 1, 2, 4, 8, 16, 32, 64, 128. Weil in digitalen Schaltungen 1 für eine hohe und 0 für eine niedrige Spannung steht, arbeiten alle Computer und Mikrocontroller mit diesem System.

Wie rechnet man eine Dezimalzahl in binär um?

Du teilst die Zahl so lange durch 2, bis 0 herauskommt, und notierst bei jedem Schritt den Rest; von unten nach oben gelesen ergeben die Reste die Binärzahl. Für 13: 6 Rest 1, 3 Rest 0, 1 Rest 1, 0 Rest 1, das Ergebnis ist 1101. Zur Kontrolle addierst du die Stellenwerte der Einsen: 8 + 4 + 1 = 13.

Warum verwendet man das Hexadezimalsystem?

Jede Hexziffer entspricht genau 4 Bit, daher lassen sich lange Binärzahlen so am einfachsten kurz und fehlerfrei schreiben. Ein 8-Bit-Byte wird mit zwei Hexziffern geschrieben, zum Beispiel B5 statt 10110101. Deshalb werden I2C-Adressen, Farbcodes, Registerwerte und Speicheradressen immer in Hex angegeben.

Was bedeuten 0b und 0x am Arduino?

Zahlen mit 0b werden als binär, Zahlen mit 0x als hexadezimal gelesen; 0b10110101, 0xB5 und 181 sind dieselbe Zahl. Welche Schreibweise du wählst, ist dem Compiler egal und betrifft nur die Lesbarkeit. Für älteren Code akzeptiert Arduino auch die 8-Bit-Form B10110101.

Was machen bitRead und bitWrite?

bitRead(x, n) liefert Bit Nummer n von x als 0 oder 1; bitWrite(x, n, v) setzt dasselbe Bit auf den Wert v. bitSet und bitClear setzen ein Bit direkt auf 1 oder 0. Diese Funktionen machen Masken und Verschiebungen lesbar; Bitnummern beginnen bei 0.

Was machen die Operatoren << und >> am Arduino?

<< schiebt die Bits nach links und verdoppelt die Zahl mit jedem Schritt; >> schiebt sie nach rechts und halbiert sie mit jedem Schritt. 1 << 3 ergibt 8, und so werden Masken gebildet, die ein einzelnes Bit auswählen. Da int am Uno 16 Bit hat, musst du bei Verschiebungen über 15 Stellen 1UL << n schreiben.

Alle Projekte ansehen
LED-Lauflicht
AR-5Mittel

LED-Lauflicht

Lichter, die nacheinander aufleuchten, als würden sie laufen. Der Arduino schaltet sechs LEDs einzeln ein; jede leuchtet kurz auf und geht wieder aus, sodass das Licht von vorn nach hinten wandert…

4.6(87)
218
Knight-Rider-Lauflicht
AR-6Mittel

Knight-Rider-Lauflicht

Das klassische Lauflicht, das hin und her wandert: Ein Lichtpunkt gleitet über sechs LEDs von einem Ende zum anderen und kommt wieder zurück.

4.8(107)
214
Zahlen 0-9 auf 7-Segment-Anzeige ausgeben
AR-41Mittel
Premium

Zahlen 0-9 auf 7-Segment-Anzeige ausgeben

Schreib selbst die bekannten Ziffern, die du aus Aufzügen und Digitaluhren kennst.

4.5(30)
43
Zahlen 0-99 auf 7-Segment-Anzeige ausgeben
AR-42Fortgeschritten
Premium

Zahlen 0-99 auf 7-Segment-Anzeige ausgeben

Eine zweistellige Anzeige aus kleinen Balken, wie bei einem Taschenrechner, zählt von 0 bis 99.

4.5(27)
35
Zahlen 0-9999 auf 4-stelliger 7-Segment-Anzeige
AR-47Mittel
Premium

Zahlen 0-9999 auf 4-stelliger 7-Segment-Anzeige

Auf einer vierstelligen Ziffernanzeige rasen die Zahlen von 0 bis 9999 und fangen dann wieder bei null an.

4.4(19)
25
Digitaluhr mit 4-stelliger 7-Segment-Anzeige
AR-48Mittel
Premium

Digitaluhr mit 4-stelliger 7-Segment-Anzeige

Eine leuchtende vierstellige Digitaluhr, ähnlich wie die am Backofen. Das Uhrmodul DS1302 hält die Zeit, der Arduino liest jede Sekunde Stunden und Minuten aus und zeigt sie auf der vierstelligen…

4.8(56)
73
Punktmatrixuhr und Kalender (MAX7219, DS1307)
AR-84Mittel
Premium

Punktmatrixuhr und Kalender (MAX7219, DS1307)

Eine leuchtende Tafel für Tisch oder Wand, die Uhrzeit und Datum als Laufschrift zeigt.

5.0(37)
59
Pixel-Schlange 8x8 Matrix
AR-88Fortgeschritten
Premium

Pixel-Schlange 8x8 Matrix

Bau das klassische Schlangenspiel selbst und spiel es. Auf einer bunten 8x8-Lichtmatrix steuerst du eine grüne Schlange mit dem Joystick und frisst rote Äpfel; mit jedem Apfel wird die Schlange…

4.7(39)
57