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.
| Dezimal | Binär | Hex | Dezimal | Binär | Hex |
|---|---|---|---|---|---|
| 0 | 0000 | 0 | 8 | 1000 | 8 |
| 1 | 0001 | 1 | 9 | 1001 | 9 |
| 2 | 0010 | 2 | 10 | 1010 | A |
| 3 | 0011 | 3 | 11 | 1011 | B |
| 4 | 0100 | 4 | 12 | 1100 | C |
| 5 | 0101 | 5 | 13 | 1101 | D |
| 6 | 0110 | 6 | 14 | 1110 | E |
| 7 | 0111 | 7 | 15 | 1111 | F |
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.
| Stellenwert | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
|---|---|---|---|---|---|---|---|---|
| 10110101 (181) | 1 | 0 | 1 | 1 | 0 | 1 | 0 | 1 |
| 00001100 (12) | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 |
| 11111111 (255) | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
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.
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öße | Arduino-Typ | Bereich ohne Vorzeichen | Bereich mit Vorzeichen |
|---|---|---|---|
| 8 Bit (1 Byte) | byte, uint8_t / int8_t | 0–255 | -128 bis 127 |
| 16 Bit (2 Byte) | int am Uno, word, uint16_t | 0–65535 | -32768 bis 32767 |
| 32 Bit (4 Byte) | long, uint32_t; int bei ESP32 und Pico | 0–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.
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}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):
| Operation | Was macht sie? | Ergebnis (binär) | Hex | Dezimal |
|---|---|---|---|---|
| a & b | Bits, die in beiden 1 sind | 10001000 | 0x88 | 136 |
| a | b | Bits, die in mindestens einer Zahl 1 sind | 11101110 | 0xEE | 238 |
| a ^ b | Bits, die sich unterscheiden | 01100110 | 0x66 | 102 |
| ~a (byte) | Alle Bits invertiert | 00110101 | 0x35 | 53 |
| a << 1 (byte) | Eine Stelle nach links, das linke Bit fällt weg | 10010100 | 0x94 | 148 |
| a >> 2 | Zwei Stellen nach rechts, die zwei rechten Bits fallen weg | 00110010 | 0x32 | 50 |
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:
| Ziel | Mit Maske | Arduino-Funktion | Beispiel (n = 3) |
|---|---|---|---|
| Bit auf 1 setzen | x |= (1 << n); | bitSet(x, n); | 00000000 → 00001000 |
| Bit auf 0 löschen | x &= ~(1 << n); | bitClear(x, n); | 11111111 → 11110111 |
| Bit umschalten | x ^= (1 << n); | bitWrite(x, n, !bitRead(x, n)); | 00001000 → 00000000 |
| Bit lesen (prüfen) | (x >> n) & 1 | bitRead(x, n); | 00001000 → 1 |
| Bit auf einen Wert setzen | x = (x & ~(1 << n)) | (v << n); | bitWrite(x, n, v); | v = 1 → 00001000 |
| Wert von Bit n | 1 << n | bit(n); | bit(3) = 8 |
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.
| Ziffer | Leuchtende Segmente | Binär (DP g f e d c b a) | Gemeinsame Kathode | Gemeinsame Anode (~) |
|---|---|---|---|---|
| 0 | a b c d e f | 00111111 | 0x3F | 0xC0 |
| 1 | b c | 00000110 | 0x06 | 0xF9 |
| 2 | a b d e g | 01011011 | 0x5B | 0xA4 |
| 3 | a b c d g | 01001111 | 0x4F | 0xB0 |
| 4 | b c f g | 01100110 | 0x66 | 0x99 |
| 5 | a c d f g | 01101101 | 0x6D | 0x92 |
| 6 | a c d e f g | 01111101 | 0x7D | 0x82 |
| 7 | a b c | 00000111 | 0x07 | 0xF8 |
| 8 | a b c d e f g | 01111111 | 0x7F | 0x80 |
| 9 | a b c d f g | 01101111 | 0x6F | 0x90 |
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.
| Verbindung | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| DS (14), serielle Daten | D11 | GPIO 23 | GP19 |
| SH_CP (11), Takt | D13 | GPIO 18 | GP18 |
| ST_CP (12), Latch | D10 | GPIO 5 | GP17 |
| OE (13) / MR (10) | GND / 5V | GND / 3V3 | GND / 3V3(OUT) |
| Q0–Q6 / Q7 | Segmente a–g / DP, jeweils über Widerstand | Gleich | Gleich |
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-Pin | Port und Bit | Uno-Pin | Port und Bit |
|---|---|---|---|
| D0–D7 | PD0–PD7 (PORTD) | D8–D13 | PB0–PB5 (PORTB) |
| A0–A5 | PC0–PC5 (PORTC) | D13 (eingebaute LED) | PB5 |
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}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.
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.
| Ausdruck | Ergebnis | Erklärung |
|---|---|---|
| (0xFC << 8) | 0x18 | 0xFC18 | Setzt zwei Bytes zu einer 16-Bit-Zahl zusammen |
| (int16_t)0xFC18 | -1000 | Mit Vorzeichen gelesen negativ, weil das linke Bit 1 ist |
| highByte(1000) | 0x03 | 1000 = 0x03E8; das High-Byte |
| lowByte(1000) | 0xE8 | Das Low-Byte (232) |
| word(0x03, 0xE8) | 1000 | Setzt die beiden Bytes wieder zusammen |
| (zustand >> 4) & 0x0F | Oberes Nibble | Trennt 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).
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
| Fehler | Was passiert? | Richtig |
|---|---|---|
| if (x & 0x04 == 0) | == wird zuerst ausgewertet, der Ausdruck wird zu x & 0 und ist immer falsch | if ((x & 0x04) == 0) |
| 2 ^ 3 als Potenz | ^ ist XOR; 2 ^ 3 = 1 | 1 << 3 oder pow(2, 3) |
| 1 << 15 oder 1 << 20 am Uno | Das 16-Bit-int läuft über: -32768 oder 0 | 1UL << 20 (unsigned long) |
| Annehmen, Serial.println(x, BIN) gebe 8 Bit aus | Führende Nullen fehlen: 12 → 1100 | 8 Bit mit bitRead in einer Schleife ausgeben |
| Führende 0 vor einer Zahl (010) | Sie wird oktal: 010 = 8 | Führende Nullen bei Dezimalzahlen entfernen |
| Ergebnis von ~ in einem int verwenden | Auch die oberen Bits werden invertiert: ~0x0F = -16 | Ergebnis einem byte zuweisen oder mit & 0xFF maskieren |
| && statt & schreiben | Es werden zwei Bedingungen verglichen, nicht Bits | Einfaches & für Bits, && für Bedingungen |
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.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
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…

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.

Zahlen 0-9 auf 7-Segment-Anzeige ausgeben
Schreib selbst die bekannten Ziffern, die du aus Aufzügen und Digitaluhren kennst.

Zahlen 0-99 auf 7-Segment-Anzeige ausgeben
Eine zweistellige Anzeige aus kleinen Balken, wie bei einem Taschenrechner, zählt von 0 bis 99.

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.

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…

Punktmatrixuhr und Kalender (MAX7219, DS1307)
Eine leuchtende Tafel für Tisch oder Wand, die Uhrzeit und Datum als Laufschrift zeigt.

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…
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

