Binair getalsysteem: hex, bits en bitbewerkingen op Arduino
Binair getalsysteem, omrekenen tussen hex en decimaal, bits en bytes, 0b en 0x op Arduino, &, |, ^, ~, <<, >> met bitRead, plus voorbeelden met 74HC595 en registers.
Het binaire getalsysteem gebruikt alleen de cijfers 0 en 1 en is de basis van alle digitale elektronica. Elke pin, elk register en elke byte in het geheugen van een Arduino is in feite een binair getal van schakelaars die aan of uit staan: 1 betekent dat een pin HIGH is en 0 dat hij LOW is. Uitdrukkingen die je in code tegenkomt, zoals 0b10110101, 0xB5 of PORTB |= (1 << 5), zien er misschien ingewikkeld uit, maar als je binair en hexadecimaal begrijpt, komen ze allemaal neer op een paar simpele regels.
In deze gids zie je eerst hoe je decimale, binaire en hexadecimale getallen met de hand in elkaar omrekent, wat bits, nibbles en bytes zijn en hoe negatieve getallen in het geheugen worden opgeslagen. Daarna leer je getallen op Arduino schrijven met 0b en 0x, één bit lezen en veranderen met AND, OR, XOR, NOT en shiftbewerkingen, en de functies bitRead, bitWrite en bitSet gebruiken. Tot slot maak je bytes klaar voor een 7-segmentdisplay en een 74HC595 en schrijf je rechtstreeks naar registers op de Uno, ESP32 en Pico.
Wat is een getalsysteem? Decimaal, binair en hexadecimaal
Het decimale stelsel dat we elke dag gebruiken heeft 10 cijfers, en elke positie is 10 keer zoveel waard als de vorige: 181 is 1×100 + 8×10 + 1×1. Het binaire stelsel heeft maar twee cijfers en elke positie is twee keer zoveel waard als de vorige; van rechts naar links zijn de plaatswaarden 1, 2, 4, 8, 16, 32, 64, 128. Het hexadecimale stelsel (kortweg hex) heeft 16 cijfers: na 0–9 komen A=10, B=11, C=12, D=13, E=14, F=15. Hex is zo populair in de elektronica omdat elk hex-cijfer precies overeenkomt met 4 bits; het is de handigste manier om lange binaire getallen kort en leesbaar op te schrijven.
| Decimaal | Binair | Hex | Decimaal | Binair | 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 |
Omrekenen tussen decimaal, binair en hex
Om decimaal naar binair om te rekenen deel je het getal steeds door 2 en noteer je de resten; als je de resten van onder naar boven leest, krijg je het binaire getal. Voor 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. Van onder naar boven gelezen geeft dat 10110101. Binair naar decimaal omrekenen is makkelijker: tel de plaatswaarden op van de posities met een 1. 10110101 = 128 + 32 + 16 + 4 + 1 = 181.
| Plaatswaarde | 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 |
Om binair naar hex om te rekenen, splits je de bits van rechts af in groepen van vier en vervang je elke groep door het bijbehorende hex-cijfer uit de tabel: 1011 0101 → B 5 → 0xB5. Andersom is net zo makkelijk: 0x3C → 0011 1100. Om hex naar decimaal om te rekenen vermenigvuldig je elk cijfer met een macht van 16: 0xB5 = 11×16 + 5 = 181, 0x3FF = 3×256 + 15×16 + 15 = 1023. Dat laatste voorbeeld komt je vast bekend voor: de bovengrens van de 10-bits analogRead-waarde van de Uno is 1023, oftewel tien enen. Het verband tussen analoge metingen en aantallen bits vind je in het ADC-artikel.
Bits, nibbles, bytes en waardebereiken
Eén binair cijfer heet een bit. 4 bits vormen een nibble, dat is één hex-cijfer; 8 bits vormen een byte, geschreven met twee hex-cijfers. De meest rechtse bit in een byte is de minst significante bit (LSB, bit 0) en de meest linkse is de meest significante bit (MSB, bit 7). Bitnummers beginnen altijd bij 0, dus de bits van een 8-bits getal zijn genummerd van 0 tot 7. Met n bits kun je 2ⁿ verschillende waarden schrijven: 8 bits geven 256, 10 bits 1024 en 16 bits 65536 verschillende waarden.
| Grootte | Arduino-type | Bereik zonder teken | Bereik met teken |
|---|---|---|---|
| 8 bits (1 byte) | byte, uint8_t / int8_t | 0–255 | -128 tot 127 |
| 16 bits (2 bytes) | int op de Uno, word, uint16_t | 0–65535 | -32768 tot 32767 |
| 32 bits (4 bytes) | long, uint32_t; int op de ESP32 en Pico | 0–4.294.967.295 | -2.147.483.648 tot 2.147.483.647 |
Negatieve getallen: tweecomplement
Microcontrollers slaan negatieve getallen op met het tweecomplement: in een getal met teken is het getal negatief als de meest linkse bit 1 is. Om het negatieve getal van een getal te krijgen, keer je al zijn bits om en tel je 1 op. 5 = 00000101; omgekeerd 11111010; tel er 1 bij op en je krijgt 11111011 = 0xFB, en dat is -5. Hetzelfde bitpatroon is een ander getal, afhankelijk van hoe je het leest: 0xFF is 255 als byte en -1 als int8_t. Daarom is het zo belangrijk om ruwe bytes van een sensor aan het juiste type toe te wijzen. Als een variabele zijn bovengrens passeert, slaat hij ook om: in een byte is 255 + 1 = 0 en met int op de Uno is 32767 + 1 = -32768; dit heet overflow.
Getallen schrijven met 0b, 0x en B op Arduino
In Arduino-code kun je hetzelfde getal op drie manieren schrijven en voor de compiler maakt het niets uit: 181 (decimaal), 0b10110101 (binair, standaard sinds C++14) en 0xB5 (hexadecimaal). Arduino herkent ook de vorm B10110101 uit oudere code, maar dat zijn constanten die alleen voor 8-bits waarden zijn gedefinieerd, en 0b is beter in nieuwe code. Welke vorm je kiest hangt af van de leesbaarheid: binair is het duidelijkst voor ledpatronen en registerinstellingen, hex voor adressen en kleurcodes en decimaal voor metingen.
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}Bitoperaties: &, |, ^, ~, << en >>
Bitbewerkingen vergelijken de bits op dezelfde positie van twee getallen één voor één. AND (&) geeft alleen 1 als beide bits 1 zijn; OR (|) geeft 1 als een van beide bits 1 is; XOR (^) geeft 1 als de bits verschillen; NOT (~) keert elke bit om. Naar links schuiven (<<) duwt de bits naar links en voegt rechts nullen toe, waardoor het getal bij elke stap met 2 wordt vermenigvuldigd; naar rechts schuiven (>>) duwt de bits naar rechts en deelt bij elke stap door 2. Dit zijn de softwarematige tegenhangers van logische poorten; hun waarheidstabellen vind je in het artikel over logische poorten en in de tool voor logische poorten. De tabel hieronder toont de resultaten voor a = 0b11001010 (202) en b = 0b10101100 (172):
| Bewerking | Wat doet het? | Resultaat (binair) | Hex | Decimaal |
|---|---|---|---|---|
| a & b | Bits die in beide getallen 1 zijn | 10001000 | 0x88 | 136 |
| a | b | Bits die in minstens één getal 1 zijn | 11101110 | 0xEE | 238 |
| a ^ b | Bits die verschillen | 01100110 | 0x66 | 102 |
| ~a (byte) | Elke bit omgekeerd | 00110101 | 0x35 | 53 |
| a << 1 (byte) | Eén plaats naar links, de meest linkse bit valt eraf | 10010100 | 0x94 | 148 |
| a >> 2 | Twee plaatsen naar rechts, de twee meest rechtse bits vallen eraf | 00110010 | 0x32 | 50 |
Let op twee details in de tabel. Als het resultaat van a << 1 in een byte wordt opgeslagen, valt de meest linkse bit eraf en blijft 148 over; in een int geeft dezelfde bewerking 404, omdat een int ruimte heeft voor de overlopende bit. Met ~a is het vergelijkbaar: als byte is het 53, maar als int berekend worden ook de bovenste bits omgekeerd en is het resultaat -203. Bij bitbewerkingen moet je altijd weten in welk type het resultaat komt. En haal & en && niet door elkaar: de eerste werkt op afzonderlijke bits, de tweede controleert of twee voorwaarden waar zijn.
Bitmaskers: één bit lezen, zetten en wissen
In echte projecten gebruik je bitbewerkingen bijna altijd met een masker. Een masker is een getal waarin alleen de bits waar het om gaat 1 zijn, meestal opgebouwd met (1 << n): (1 << 3) = 0b00001000. Met een masker doe je vier basisbewerkingen en Arduino biedt voor elk ervan een kant-en-klare functie. De onderstaande code bewaart de status van 8 LED's in één byte in plaats van 8 aparte bool-variabelen en spiegelt die naar de LED's op D2–D9:
| Doel | Met een masker | Arduino-functie | Voorbeeld (n = 3) |
|---|---|---|---|
| Zet de bit op 1 | x |= (1 << n); | bitSet(x, n); | 00000000 → 00001000 |
| Zet de bit op 0 | x &= ~(1 << n); | bitClear(x, n); | 11111111 → 11110111 |
| Wissel de bit om | x ^= (1 << n); | bitWrite(x, n, !bitRead(x, n)); | 00001000 → 00000000 |
| Lees (test) de bit | (x >> n) & 1 | bitRead(x, n); | 00001000 → 1 |
| Schrijf een gegeven waarde naar de bit | x = (x & ~(1 << n)) | (v << n); | bitWrite(x, n, v); | v = 1 → 00001000 |
| Waarde van 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 klaarmaken voor een 7-segmentdisplay
De acht onderdelen van een 7-segmentdisplay (segmenten a–g en de decimale punt) passen precies in één byte. Als je bit 0 aan segment a toewijst, bit 6 aan segment g en bit 7 aan de decimale punt (DP), kan elk cijfer als één getal worden uitgedrukt. Het cijfer 2 wordt bijvoorbeeld getekend met de segmenten a, b, d, e en g: 1 + 2 + 8 + 16 + 64 = 91 = 0x5B. Bij displays met gemeenschappelijke anode brandt een segment bij LOW, dus keer je dezelfde tabel om met ~. Voor details over de bedrading van de segmenten zie het artikel over het 7-segmentdisplay.
| Cijfer | Brandende segmenten | Binair (DP g f e d c b a) | Gemeenschappelijke kathode | Gemeenschappelijke 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 |
De byte naar uitgangen sturen met een 74HC595
Het 74HC595-schuifregister verdeelt één byte over acht uitgangen met slechts drie pins, en het is de chip waarin je bitbewerkingen het duidelijkst ziet: elke bit van de byte die je verstuurt, laat één uitgang branden of zet hem uit. Als shiftOut met MSBFIRST wordt gebruikt, wordt bit 7 als eerste verstuurd en komt die in Q7 terecht, terwijl bit 0 in Q0 belandt. Als je dus Q0 aansluit op segment a, Q6 op g en Q7 op DP, werkt de tabel hierboven direct. Voor alle pins van de chip en het doorkoppelen van meerdere chips zie het artikel over het 74HC595-schuifregister.
| Aansluiting | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| DS (14), seriële data | D11 | GPIO 23 | GP19 |
| SH_CP (11), klok | 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 | Segmenten a–g / DP, elk via een weerstand | Idem | Idem |
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}Rechtstreeks naar registers schrijven: PORTB en DDRB
Op de ATmega328P van de Uno zijn de pins gegroepeerd in poorten van 8 pins, en elke poort heeft drie registers: DDRx bevat de pinrichting (1 = uitgang), PORTx het uitgangsniveau en PINx het niveau dat wordt gelezen. De pins D8–D13 zitten op poort B; D13 (de ingebouwde LED) is PB5, bit 5 van PORTB. pinMode en digitalWrite veranderen eigenlijk deze bits, maar omdat ze het pinnummer eerst naar een poort vertalen, kosten ze enkele microseconden. Rechtstreeks naar het register schrijven is één machine-instructie en duurt 2 klokcycli bij 16 MHz, ongeveer 125 nanoseconden. Je kunt zo ook meerdere pins van dezelfde poort op precies hetzelfde moment veranderen.
| Uno-pin | Poort en bit | Uno-pin | Poort en bit |
|---|---|---|---|
| D0–D7 | PD0–PD7 (PORTD) | D8–D13 | PB0–PB5 (PORTB) |
| A0–A5 | PC0–PC5 (PORTC) | D13 (ingebouwde 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 aansturen via registers op de ESP32
Op de ESP32 worden pins bestuurd met 32-bits registers, en anders dan bij AVR zijn er aparte set- en clear-registers: elke 1-bit die je naar GPIO_OUT_W1TS_REG schrijft (write 1 to set) maakt de bijbehorende pin HIGH, elke 1-bit die je naar GPIO_OUT_W1TC_REG schrijft (write 1 to clear) maakt hem LOW, en 0-bits raken geen enkele pin aan. Omdat hiervoor geen lezen-wijzigen-schrijven nodig is, is het veilig met interrupts en over de twee cores heen. Deze twee registers dekken alleen GPIO 0–31; voor 32 en hoger worden de GPIO_OUT1-registers gebruikt.
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}Sensorgegevens samenvoegen en splitsen
I2C- en SPI-sensoren sturen 16-bits metingen meestal als twee aparte bytes: eerst de hoge byte (MSB), dan de lage byte (LSB). Om ze samen te voegen schuif je de hoge byte 8 plaatsen naar links en combineer je hem met OR met de lage byte: int16_t raw = (msb << 8) | lsb;. Als een versnellingsmeter bijvoorbeeld 0xFC en 0x18 stuurt, is het resultaat 0xFC18; als int16_t gelezen is dit getal -1000, omdat de meest linkse bit 1 is. In de andere richting, om een getal te versturen of naar EEPROM te schrijven, zijn er highByte(x) en lowByte(x), en word(high, low) om twee bytes samen te voegen. De I2C-communicatie zelf vind je in Wat is I2C?, en een sensor die met ruwe gegevens van twee bytes werkt in het artikel over de MPU6050.
| Expressie | Resultaat | Uitleg |
|---|---|---|
| (0xFC << 8) | 0x18 | 0xFC18 | Voegt twee bytes samen tot één 16-bits getal |
| (int16_t)0xFC18 | -1000 | Negatief bij een uitlezing met teken omdat de meest linkse bit 1 is |
| highByte(1000) | 0x03 | 1000 = 0x03E8; de hoge byte |
| lowByte(1000) | 0xE8 | De lage byte (232) |
| word(0x03, 0xE8) | 1000 | Voegt de twee bytes weer samen |
| (state >> 4) & 0x0F | Bovenste nibble | Haalt de bovenste 4 bits uit een byte (bijv. een registerveld) |
Bits op de Raspberry Pi Pico en in MicroPython
In MicroPython gelden dezelfde operatoren en zijn er bovendien kant-en-klare omrekenfuncties: bin(), hex() en int(text, base). Omdat Python-gehele getallen onbeperkt groeien, moet je de resultaten van ~ en << maskeren met & 0xFF als ze in een byte moeten passen. De RP2040-chip van de Pico heeft net als de ESP32 aparte set-, clear- en XOR-registers, en je kunt er rechtstreeks naar schrijven met machine.mem32. De onderstaande code laat de ingebouwde LED van de Pico op GP25 knipperen met het XOR-register (op de Pico W is de ingebouwde LED aangesloten op de wifichip, gebruik daar dus een 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)Projectideeën met bitbewerkingen
- Binaire teller: Bouw een teller die op 8 LED's van 0 tot 255 telt en zie het binaire stelsel met eigen ogen; met de ene knop tel je er één bij, met de andere trek je er één af.
- Knight Rider-effect: Schuif een byte met << en >> om de LED's heen en weer te laten lopen; de opbouw stap voor stap vind je in het artikel over Knight Rider en looplicht.
- Digitale klok: Toon de tijd op een 7-segmentdisplay met vier cijfers en laat de decimale punt van het tweede cijfer elke seconde knipperen met het masker 0x80.
- Pictogrammen op een ledmatrix: Teken elke rij van een 8×8-matrix als een byte; ontwerp hartjes, pijlen of letters met 0b. Het artikel over de MAX7219-ledmatrix gebruikt deze methode.
- Instellingsvlaggen: Bewaar aan/uit-instellingen zoals geluid aan, helder scherm en alarm ingesteld in de bits van één byte en schrijf ze in één keer naar EEPROM.
- Adres kiezen met een DIP-switch: Lees een DIP-switch met 4 schakelaars uit om een apparaatadres tussen 0 en 15 te krijgen.
Veelgemaakte fouten en hoe je ze oplost
| Fout | Wat gebeurt er? | Juiste vorm |
|---|---|---|
| if (x & 0x04 == 0) | == wordt eerst uitgevoerd, de expressie wordt x & 0 en is altijd onwaar | if ((x & 0x04) == 0) |
| 2 ^ 3 gebruiken voor een macht | ^ is XOR; 2 ^ 3 = 1 | 1 << 3 of pow(2, 3) |
| 1 << 15 of 1 << 20 op de Uno | De 16-bits int loopt over: -32768 of 0 | 1UL << 20 (unsigned long) |
| Ervan uitgaan dat Serial.println(x, BIN) 8 bits afdrukt | Voorloopnullen worden niet afgedrukt: 12 → 1100 | Druk 8 bits af in een lus met bitRead |
| Een 0 voor een getal zetten (010) | Het wordt octaal: 010 = 8 | Haal voorloopnullen van decimale getallen weg |
| Het resultaat van ~ in een int gebruiken | De bovenste bits worden ook omgekeerd: ~0x0F = -16 | Wijs het resultaat toe aan een byte of maskeer het met & 0xFF |
| && schrijven in plaats van & | Er worden twee voorwaarden vergeleken, geen bits | Enkele & voor bits, && voor voorwaarden |
Binaire en hexadecimale getallen en bitbewerkingen lijken in het begin abstract, maar je komt ze elke dag tegen in de elektronica, van een rij LED's aansturen met één byte tot sensorgegevens samenvoegen. Samen geleerd met de basis van Arduino-programmeren maken ze je code korter en sneller. In de BlueGrays-app kun je projecten met 7-segmenttellers, een digitale klok, looplichten, Knight Rider en ledmatrices bekijken, met schakelschema's stap voor stap en code die met deze bitbewerkingen is geschreven.
Veelgestelde vragen
Wat is het binaire getalsysteem?
Het binaire getalsysteem gebruikt alleen de cijfers 0 en 1, en elke positie is twee keer zoveel waard als de vorige. Van rechts naar links zijn de plaatswaarden 1, 2, 4, 8, 16, 32, 64, 128. Omdat 1 in digitale schakelingen een hoge spanning voorstelt en 0 een lage spanning, werken alle computers en microcontrollers met dit stelsel.
Hoe reken je een decimaal getal om naar binair?
Deel het getal steeds door 2 tot het 0 bereikt en schrijf bij elke stap de rest op; de resten van onder naar boven gelezen geven het binaire getal. Voor 13: 6 rest 1, 3 rest 0, 1 rest 1, 0 rest 1, dus het resultaat is 1101. Controleer door de plaatswaarden van de enen op te tellen: 8 + 4 + 1 = 13.
Waarom wordt het hexadecimale (hex) stelsel gebruikt?
Elk hex-cijfer komt precies overeen met 4 bits, dus het is de makkelijkste manier om lange binaire getallen kort en foutloos op te schrijven. Een byte van 8 bits schrijf je met twee hex-cijfers, bijvoorbeeld B5 in plaats van 10110101. Daarom worden I2C-adressen, kleurcodes, registerwaarden en geheugenadressen altijd in hex opgegeven.
Wat betekenen 0b en 0x op Arduino?
Getallen die met 0b beginnen worden als binair gelezen en getallen die met 0x beginnen als hexadecimaal; 0b10110101, 0xB5 en 181 zijn hetzelfde getal. Welke je schrijft maakt voor de compiler niet uit, alleen voor de leesbaarheid. Arduino accepteert ook de 8-bits vorm B10110101 uit oudere code.
Wat doen bitRead en bitWrite?
bitRead(x, n) geeft bit nummer n van x terug als 0 of 1; bitWrite(x, n, v) zet dezelfde bit op de waarde v. bitSet en bitClear zetten een bit direct op 1 of 0. Deze functies maken maskeren en schuiven leesbaar; bitnummers beginnen bij 0.
Wat doen de operatoren << en >> op Arduino?
<< schuift de bits naar links en vermenigvuldigt het getal bij elke stap met 2; >> schuift ze naar rechts en deelt bij elke stap door 2. 1 << 3 is 8, en maskers die één bit selecteren worden zo opgebouwd. Omdat int op de Uno 16 bits is, moet je voor shifts groter dan 15 1UL << n schrijven.
Projecten om hierna te bouwen
Alle projecten bekijken
LED-looplicht
Lichten die na elkaar aangaan, alsof ze rennen. De Arduino laat zes LED's een voor een branden; elke LED licht even op en gaat uit, zodat het licht van begin tot eind loopt en dan opnieuw begint.

Knight Rider-ledeffect
Het klassieke scannerlicht: een lichtpunt schuift van het ene uiteinde van zes LED's naar het andere en komt dan terug.

Cijfers 0-9 tonen op een 7-segmentdisplay
Schrijf zelf die bekende cijfers die je in liften en digitale klokken ziet. Op een display van zeven kleine lichtbalkjes toont de Arduino elke seconde een cijfer van 0 tot 9 en begint daarna opnieuw.

Getallen van 0-99 tonen op een 7-segmentdisplay
Een display met twee cijfers, opgebouwd uit kleine streepjes zoals op een rekenmachine, telt van 0 tot 99.

0-9999 tonen op een 7-segmentdisplay met 4 cijfers
Op een getaldisplay met vier cijfers razen getallen van 0 tot 9999 voorbij en beginnen dan weer bij nul.

Digitale klok met 7-segmentdisplay met 4 cijfers
Een lichtgevende digitale klok met vier cijfers, zoals op een keukenoven. De DS1302-klokmodule houdt de tijd bij en de Arduino leest elke seconde uren en minuten uit en toont ze op het display met…

Dotmatrix-klok en -kalender (MAX7219, DS1307)
Een oplichtend bord voor op je bureau of aan de muur dat de tijd en de datum toont in scrollende tekst.

Pixelslang 8x8-matrix
Bouw het klassieke slangenspel zelf en speel het. Op een kleurrijke 8x8-lichtmatrix stuur je met een joystick een groene slang en eet je rode appels.
Meer artikelen
- 74HC595 Arduino-tutorial: schuifregister voor 8+ LED's op 3 pinnen
- Een 7-segmentdisplay gebruiken: cijfers tonen met Arduino, gemeenschappelijke anode vs kathode
- Logische poorten uitgelegd: waarheidstabellen van AND, OR, NOT en XOR, en Arduino
- Arduino programmeren: variabelen, lussen en functies voor beginners
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

