Basis · 12 min leestijd

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.

DecimaalBinairHexDecimaalBinairHex
000000810008
100011910019
200102101010A
300113111011B
401004121100C
501015131101D
601106141110E
701117151111F

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.

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

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.

De rekenmachine van je computer in programmeursmodus en de Arduino Serial Monitor zijn de snelste manieren om omrekeningen te controleren. Serial.println(181, BIN) drukt 10110101 af en Serial.println(181, HEX) drukt B5 af. Toch maakt het je een stuk makkelijker om registertabellen en datasheets te lezen als je een paar keer met de hand omrekent.

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.

GrootteArduino-typeBereik zonder tekenBereik met teken
8 bits (1 byte)byte, uint8_t / int8_t0–255-128 tot 127
16 bits (2 bytes)int op de Uno, word, uint16_t0–65535-32768 tot 32767
32 bits (4 bytes)long, uint32_t; int op de ESP32 en Pico0–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.

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}
Als je in C++ een nul voor een getal zet, wordt het een octaal getal: 010 is acht, geen tien, en 0255 is 173. Als je 08 of 09 schrijft om pinnummers of tijden uit te lijnen, geeft de compiler een foutmelding; schrijf je 010, dan doet hij stilletjes het verkeerde. Zet nooit een voorloopnul voor decimale getallen.

Bitoperaties: &amp;, |, ^, ~, &lt;&lt; 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):

BewerkingWat doet het?Resultaat (binair)HexDecimaal
a & bBits die in beide getallen 1 zijn100010000x88136
a | bBits die in minstens één getal 1 zijn111011100xEE238
a ^ bBits die verschillen011001100x66102
~a (byte)Elke bit omgekeerd001101010x3553
a << 1 (byte)Eén plaats naar links, de meest linkse bit valt eraf100101000x94148
a >> 2Twee plaatsen naar rechts, de twee meest rechtse bits vallen eraf001100100x3250

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:

DoelMet een maskerArduino-functieVoorbeeld (n = 3)
Zet de bit op 1x |= (1 << n);bitSet(x, n);00000000 → 00001000
Zet de bit op 0x &= ~(1 << n);bitClear(x, n);11111111 → 11110111
Wissel de bit omx ^= (1 << n);bitWrite(x, n, !bitRead(x, n));00001000 → 00000000
Lees (test) de bit(x >> n) & 1bitRead(x, n);00001000 → 1
Schrijf een gegeven waarde naar de bitx = (x & ~(1 << n)) | (v << n);bitWrite(x, n, v);v = 1 → 00001000
Waarde van 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 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.

CijferBrandende segmentenBinair (DP g f e d c b a)Gemeenschappelijke kathodeGemeenschappelijke 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

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.

AansluitingArduino UnoESP32Raspberry Pi Pico
DS (14), seriële dataD11GPIO 23GP19
SH_CP (11), klokD13GPIO 18GP18
ST_CP (12), latchD10GPIO 5GP17
OE (13) / MR (10)GND / 5VGND / 3V3GND / 3V3(OUT)
Q0–Q6 / Q7Segmenten a–g / DP, elk via een weerstandIdemIdem
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}

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-pinPoort en bitUno-pinPoort en bit
D0–D7PD0–PD7 (PORTD)D8–D13PB0–PB5 (PORTB)
A0–A5PC0–PC5 (PORTC)D13 (ingebouwde 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 is boardspecifiek: een PORTB-regel die op de Uno werkt, bestuurt op een Mega andere pins, bestuurt niets op een ESP32 of Pico en compileert daar niet eens. Bovendien zijn bit 0 en 1 van PORTD de pins van de seriële poort; een regel die in één keer de hele poort beschrijft, zoals PORTD = 0xFF, kan Serial kapotmaken. Verander met een masker alleen de bits waar het om gaat en gebruik registercode alleen waar snelheid echt belangrijk is.

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.

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}

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.

ExpressieResultaatUitleg
(0xFC << 8) | 0x180xFC18Voegt twee bytes samen tot één 16-bits getal
(int16_t)0xFC18-1000Negatief bij een uitlezing met teken omdat de meest linkse bit 1 is
highByte(1000)0x031000 = 0x03E8; de hoge byte
lowByte(1000)0xE8De lage byte (232)
word(0x03, 0xE8)1000Voegt de twee bytes weer samen
(state >> 4) & 0x0FBovenste nibbleHaalt 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).

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)

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

FoutWat gebeurt er?Juiste vorm
if (x & 0x04 == 0)== wordt eerst uitgevoerd, de expressie wordt x & 0 en is altijd onwaarif ((x & 0x04) == 0)
2 ^ 3 gebruiken voor een macht^ is XOR; 2 ^ 3 = 11 << 3 of pow(2, 3)
1 << 15 of 1 << 20 op de UnoDe 16-bits int loopt over: -32768 of 01UL << 20 (unsigned long)
Ervan uitgaan dat Serial.println(x, BIN) 8 bits afdruktVoorloopnullen worden niet afgedrukt: 12 → 1100Druk 8 bits af in een lus met bitRead
Een 0 voor een getal zetten (010)Het wordt octaal: 010 = 8Haal voorloopnullen van decimale getallen weg
Het resultaat van ~ in een int gebruikenDe bovenste bits worden ook omgekeerd: ~0x0F = -16Wijs het resultaat toe aan een byte of maskeer het met & 0xFF
&& schrijven in plaats van &Er worden twee voorwaarden vergeleken, geen bitsEnkele & voor bits, && voor voorwaarden
Als je twijfelt over een bitbewerking, druk dan het resultaat in drie vormen af: Serial.println(x), Serial.println(x, BIN) en Serial.println(x, HEX). Als je dezelfde waarde decimaal, binair en hex ziet, zie je meteen of het masker of de shift de bits heeft geraakt die je verwachtte.

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.

Alle projecten bekijken
LED-looplicht
AR-5Gemiddeld

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.

4.6(87)
218
Knight Rider-ledeffect
AR-6Gemiddeld

Knight Rider-ledeffect

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

4.8(107)
214
Cijfers 0-9 tonen op een 7-segmentdisplay
AR-41Gemiddeld
Premium

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.

4.5(30)
43
Getallen van 0-99 tonen op een 7-segmentdisplay
AR-42Gevorderd
Premium

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.

4.5(27)
35
0-9999 tonen op een 7-segmentdisplay met 4 cijfers
AR-47Gemiddeld
Premium

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.

4.4(19)
25
Digitale klok met 7-segmentdisplay met 4 cijfers
AR-48Gemiddeld
Premium

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…

4.8(56)
73
Dotmatrix-klok en -kalender (MAX7219, DS1307)
AR-84Gemiddeld
Premium

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.

5.0(37)
59
Pixelslang 8x8-matrix
AR-88Gevorderd
Premium

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.

4.7(39)
57