İkilik Sayı Sistemi: Binary, Hex ve Arduino Bit İşlemleri
İkilik sayı sistemi, onaltılık ve onluk dönüşümler, bit ve bayt, Arduino'da 0b ve 0x, &, |, ^, ~, <<, >> ile bitRead, 74HC595 ve register örnekleri.
İkilik sayı sistemi (binary), yalnızca 0 ve 1 rakamlarını kullanan ve bütün dijital elektroniğin temelini oluşturan sayı sistemidir. Arduino'nun her pini, her register'ı ve hafızadaki her bayt aslında açık ya da kapalı anahtarlardan oluşan bir ikilik sayıdır: 1 bir pinin HIGH, 0 ise LOW olduğu anlamına gelir. Kodda karşına çıkan 0b10110101, 0xB5 ya da PORTB |= (1 << 5) gibi ifadeler korkutucu görünse de, ikilik ve onaltılık sistemi bir kez anladığında hepsi birkaç basit kurala iner.
Bu rehberde önce onluk, ikilik ve onaltılık sayıları birbirine elle nasıl dönüştüreceğini, bit, nibble ve bayt kavramlarını ve negatif sayıların bellekte nasıl tutulduğunu göreceksin. Ardından Arduino'da sayıları 0b ve 0x ile yazmayı, AND, OR, XOR, NOT ve kaydırma işlemleriyle tek bir biti okumayı ve değiştirmeyi, bitRead, bitWrite ve bitSet fonksiyonlarını öğreneceksin. Son olarak 7 segment ekran ve 74HC595 için bayt hazırlayacak, Uno, ESP32 ve Pico'da register'lara doğrudan yazacaksın.
Sayı sistemi nedir? Onluk, ikilik ve onaltılık
Günlük hayatta kullandığımız onluk (decimal) sistemde 10 rakam vardır ve her basamak bir öncekinin 10 katı değer taşır: 181 sayısı 1×100 + 8×10 + 1×1'dir. İkilik sistemde yalnızca iki rakam vardır ve her basamak bir öncekinin 2 katıdır; sağdan sola basamak değerleri 1, 2, 4, 8, 16, 32, 64, 128 diye gider. Onaltılık (hexadecimal, kısaca hex) sistemde ise 16 rakam vardır: 0–9'dan sonra A=10, B=11, C=12, D=13, E=14, F=15 gelir. Hex'in elektronikte bu kadar sevilmesinin sebebi, her hex rakamının tam olarak 4 bite karşılık gelmesidir; uzun ikilik sayıları kısa ve okunur yazmanın en pratik yoludur.
| Onluk | İkilik | Hex | Onluk | İkilik | 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 |
Dönüşümler: onluk, ikilik ve hex arasında
Onluktan ikiliğe çevirmek için sayıyı sürekli 2'ye böler ve kalanları not edersin; kalanları aşağıdan yukarıya okuduğunda ikilik sayı çıkar. 181 için: 181/2 = 90 kalan 1, 90/2 = 45 kalan 0, 45/2 = 22 kalan 1, 22/2 = 11 kalan 0, 11/2 = 5 kalan 1, 5/2 = 2 kalan 1, 2/2 = 1 kalan 0, 1/2 = 0 kalan 1. Aşağıdan yukarı okuyunca 10110101 olur. İkilikten onluğa dönüş daha kolaydır: 1 olan basamakların değerlerini toplarsın. 10110101 = 128 + 32 + 16 + 4 + 1 = 181.
| Basamak değeri | 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 |
İkilikten hex'e çevirmek için bitleri sağdan başlayarak dörderli gruplara ayırır ve her grubu tablodaki hex rakamıyla değiştirirsin: 1011 0101 → B 5 → 0xB5. Ters yön de aynı kolaylıktadır: 0x3C → 0011 1100. Hex'ten onluğa çevirmek için her basamağı 16'nın kuvvetiyle çarparsın: 0xB5 = 11×16 + 5 = 181, 0x3FF = 3×256 + 15×16 + 15 = 1023. Son örnek tanıdık gelmeli: Uno'nun 10 bitlik analogRead değerinin üst sınırı 1023, yani on tane 1'dir. Analog okuma ile bit sayısı arasındaki ilişkiyi ADC yazısında bulabilirsin.
Bit, nibble, bayt ve değer aralıkları
Tek bir ikilik basamağa bit denir. 4 bit bir nibble, yani tek bir hex rakamıdır; 8 bit bir bayt (byte) eder ve iki hex rakamıyla yazılır. Bir bayttaki en sağdaki bit en düşük değerli bit (LSB, bit 0), en soldaki ise en yüksek değerli bittir (MSB, bit 7). Bit numaraları her zaman 0'dan başlar; bu yüzden 8 bitlik bir sayının bitleri 0–7 diye numaralanır. n bitle 2ⁿ farklı değer yazılabilir: 8 bit 256, 10 bit 1024, 16 bit 65536 farklı değer demektir.
| Boyut | Arduino türü | İşaretsiz aralık | İşaretli aralık |
|---|---|---|---|
| 8 bit (1 bayt) | byte, uint8_t / int8_t | 0–255 | -128 ile 127 |
| 16 bit (2 bayt) | Uno'da int, word, uint16_t | 0–65535 | -32768 ile 32767 |
| 32 bit (4 bayt) | long, uint32_t; ESP32 ve Pico'da int | 0–4.294.967.295 | -2.147.483.648 ile 2.147.483.647 |
Negatif sayılar: ikiye tümleyen
Mikrodenetleyiciler negatif sayıları ikiye tümleyen (two's complement) yöntemiyle tutar: işaretli bir sayıda en soldaki bit 1 ise sayı negatiftir. Bir sayının negatifini bulmak için bütün bitlerini tersler ve 1 eklersin. 5 = 00000101; tersi 11111010; 1 ekleyince 11111011 = 0xFB, yani -5. Aynı bit dizisi, onu nasıl okuduğuna göre farklı bir sayıdır: 0xFF bir byte olarak 255, bir int8_t olarak -1'dir. Bu yüzden sensörden gelen bayt ham veriyi doğru türe atamak çok önemlidir. Bir değişken üst sınırını aşınca da baştan başlar: byte türünde 255 + 1 = 0, Uno'da int türünde 32767 + 1 = -32768 olur ve buna taşma (overflow) denir.
Arduino'da 0b, 0x ve B ile sayı yazmak
Arduino kodunda aynı sayıyı üç farklı biçimde yazabilirsin ve derleyici için hiçbir farkı yoktur: 181 (onluk), 0b10110101 (ikilik, C++14'ten beri standart) ve 0xB5 (onaltılık). Arduino ayrıca eski kodlardan kalan B10110101 biçimini de tanır; ama bu yalnızca 8 bitlik değerler için tanımlı sabitlerdir ve yeni kodda 0b kullanmak daha iyidir. Hangi biçimin seçileceği okunabilirliğe bağlıdır: LED desenleri ve register ayarları için ikilik, adresler ve renk kodları için hex, ölçümler için onluk en anlaşılır olanıdır.
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}Bit işlemleri: &, |, ^, ~, << ve >>
Bit işlemleri iki sayının aynı sıradaki bitlerini tek tek karşılaştırır. AND (&) yalnızca iki bit de 1 ise 1 verir; OR (|) bitlerden biri 1 ise 1 verir; XOR (^) bitler farklıysa 1 verir; NOT (~) bütün bitleri tersler. Sola kaydırma (<<) bitleri sola iter ve sağdan 0 ekler, her adımda sayı 2 ile çarpılır; sağa kaydırma (>>) bitleri sağa iter, her adımda sayı 2'ye bölünür. Bunlar mantık kapılarının yazılımdaki karşılığıdır; doğruluk tablolarını mantık kapıları yazısında ve mantık kapısı aracında görebilirsin. Aşağıdaki tabloda a = 0b11001010 (202) ve b = 0b10101100 (172) için sonuçlar var:
| İşlem | Ne yapar? | Sonuç (ikilik) | Hex | Onluk |
|---|---|---|---|---|
| a & b | İkisi de 1 olan bitler | 10001000 | 0x88 | 136 |
| a | b | En az biri 1 olan bitler | 11101110 | 0xEE | 238 |
| a ^ b | Farklı olan bitler | 01100110 | 0x66 | 102 |
| ~a (byte) | Bütün bitler terslenir | 00110101 | 0x35 | 53 |
| a << 1 (byte) | Bir basamak sola, soldaki bit düşer | 10010100 | 0x94 | 148 |
| a >> 2 | İki basamak sağa, sağdaki iki bit düşer | 00110010 | 0x32 | 50 |
Tabloda iki ayrıntıya dikkat et. a << 1 sonucu bir byte değişkenine yazıldığında en soldaki bit dışarı düşer ve 148 kalır; aynı işlem bir int'te yapılırsa 404 olur, çünkü int'te taşan bite yer vardır. ~a da benzerdir: byte olarak 53'tür, ama int olarak hesaplandığında üst bitler de terslenir ve -203 çıkar. Bit işlemlerinde sonucu hangi türde tuttuğunu her zaman bilmelisin. & ile &&'yi de karıştırma: birincisi bitleri tek tek işler, ikincisi iki koşulun doğru olup olmadığına bakar.
Bit maskeleri: tek bir biti okumak, açmak, kapatmak
Gerçek projelerde bit işlemleri neredeyse her zaman bir maske ile kullanılır. Maske, yalnızca ilgilendiğin bitleri 1 olan bir sayıdır ve genellikle (1 << n) ile oluşturulur: (1 << 3) = 0b00001000. Bu maskeyle dört temel işlem yapılır ve Arduino her biri için hazır bir fonksiyon da sunar. Aşağıdaki kod 8 LED'in durumunu 8 ayrı bool değişkeni yerine tek bir baytta tutar ve D2–D9'daki LED'lere yansıtır:
| Amaç | Maskeyle | Arduino fonksiyonu | Örnek (n = 3) |
|---|---|---|---|
| Biti 1 yap (set) | x |= (1 << n); | bitSet(x, n); | 00000000 → 00001000 |
| Biti 0 yap (clear) | x &= ~(1 << n); | bitClear(x, n); | 11111111 → 11110111 |
| Biti tersle (toggle) | x ^= (1 << n); | bitWrite(x, n, !bitRead(x, n)); | 00001000 → 00000000 |
| Biti oku (test) | (x >> n) & 1 | bitRead(x, n); | 00001000 → 1 |
| Biti verilen değere yaz | x = (x & ~(1 << n)) | (v << n); | bitWrite(x, n, v); | v = 1 → 00001000 |
| n. bitin değeri | 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}7 segment ekran için bayt hazırlamak
7 segment ekranın sekiz parçası (a–g segmentleri ve nokta) tam olarak bir bayta sığar. Bit 0'ı a segmentine, bit 6'yı g segmentine, bit 7'yi noktaya (DP) atarsan her rakam tek bir sayıyla ifade edilir. Örneğin 2 rakamı a, b, d, e ve g segmentleriyle çizilir: 1 + 2 + 8 + 16 + 64 = 91 = 0x5B. Ortak anotlu ekranlarda segment LOW ile yandığı için aynı tabloyu ~ ile tersleyip kullanırsın. Segment bağlantılarının ayrıntıları için 7 segment display yazısına bakabilirsin.
| Rakam | Yanan segmentler | İkilik (DP g f e d c b a) | Ortak katot | Ortak anot (~) |
|---|---|---|---|---|
| 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 |
74HC595 ile baytı çıkışlara göndermek
74HC595 kaydırmalı yazmacı, bir baytı yalnızca üç pinle sekiz çıkışa dağıtır ve bit işlemlerini en net gördüğün entegredir: gönderdiğin baytın her biti bir çıkışı yakar ya da söndürür. shiftOut fonksiyonu MSBFIRST ile kullanıldığında bit 7 önce gönderilir ve en sonunda Q7'ye yerleşir; bit 0 ise Q0'a gelir. Bu yüzden Q0'ı a segmentine, Q6'yı g'ye, Q7'yi DP'ye bağlarsan yukarıdaki tablo doğrudan çalışır. Entegrenin bütün pinleri ve zincirleme bağlantısı için 74HC595 shift register yazısına göz at.
| Bağlantı | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| DS (14), seri veri | D11 | GPIO 23 | GP19 |
| SH_CP (11), saat | 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 | a–g segmentleri / DP, her biri dirençle | Aynı | Aynı |
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}Register'a doğrudan yazmak: PORTB ve DDRB
Uno'daki ATmega328P'de pinler 8'li gruplar hâlinde portlara ayrılmıştır ve her portun üç register'ı vardır: DDRx pinin yönünü (1 = çıkış), PORTx çıkış seviyesini, PINx ise okunan seviyeyi tutar. D8–D13 pinleri B portundadır; D13 (dahili LED) PB5'tir, yani PORTB'nin 5. bitidir. pinMode ve digitalWrite aslında bu bitleri değiştirir, ama önce pin numarasını porta çevirdiği için birkaç mikrosaniye sürer. Register'a doğrudan yazmak tek bir makine komutudur ve 16 MHz'de 2 saat çevriminde, yani yaklaşık 125 nanosaniyede biter. Ayrıca aynı porttaki birden fazla pini tam aynı anda değiştirmeni sağlar.
| Uno pini | Port ve bit | Uno pini | Port ve bit |
|---|---|---|---|
| D0–D7 | PD0–PD7 (PORTD) | D8–D13 | PB0–PB5 (PORTB) |
| A0–A5 | PC0–PC5 (PORTC) | D13 (dahili 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}ESP32'de register ile pin sürmek
ESP32'de pinler 32 bitlik register'larla yönetilir ve AVR'den farklı olarak ayrı set ve clear register'ları vardır: GPIO_OUT_W1TS_REG'e (write 1 to set) yazdığın her 1 biti ilgili pini HIGH yapar, GPIO_OUT_W1TC_REG'e (write 1 to clear) yazdığın her 1 biti LOW yapar; 0 olan bitler hiçbir pine dokunmaz. Bu yapı oku-değiştir-yaz gerektirmediği için kesmeler ve iki çekirdek arasında güvenlidir. Bu iki register yalnızca GPIO 0–31'i kapsar; 32 ve üstü için GPIO_OUT1 register'ları kullanılır.
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}Sensör verisini birleştirmek ve bölmek
I2C ve SPI sensörleri 16 bitlik ölçümleri genellikle iki ayrı bayt olarak gönderir: önce yüksek bayt (MSB), sonra düşük bayt (LSB). Bunları birleştirmek için yüksek baytı 8 basamak sola kaydırıp düşük baytla OR'larsın: int16_t ham = (msb << 8) | lsb;. Örneğin bir ivme sensörü 0xFC ve 0x18 gönderirse sonuç 0xFC18'dir; int16_t olarak okunduğunda en soldaki bit 1 olduğu için bu sayı -1000'dir. Ters yönde bir sayıyı göndermek ya da EEPROM'a yazmak için highByte(x) ve lowByte(x), iki baytı birleştirmek için word(yuksek, dusuk) fonksiyonları da vardır. I2C haberleşmesinin kendisini I2C nedir? yazısında, iki baytlık ham veriyle çalışan bir sensörü MPU6050 yazısında görebilirsin.
| İfade | Sonuç | Açıklama |
|---|---|---|
| (0xFC << 8) | 0x18 | 0xFC18 | İki baytı tek 16 bitlik sayıda birleştirir |
| (int16_t)0xFC18 | -1000 | En soldaki bit 1 olduğu için işaretli okumada negatif |
| highByte(1000) | 0x03 | 1000 = 0x03E8; yüksek bayt |
| lowByte(1000) | 0xE8 | Düşük bayt (232) |
| word(0x03, 0xE8) | 1000 | İki baytı yeniden birleştirir |
| (durum >> 4) & 0x0F | Üst nibble | Bir baytın üst 4 bitini ayırır (ör. bir register alanı) |
Raspberry Pi Pico ve MicroPython'da bitler
MicroPython'da da aynı operatörler geçerlidir; ek olarak dönüşüm için hazır fonksiyonlar vardır: bin(), hex() ve int(metin, taban). Python'un tam sayıları sınırsız büyüdüğü için ~ ve << sonuçlarını bir bayta sığdırmak istiyorsan & 0xFF ile maskelemen gerekir. Pico'nun RP2040 yongasında da ESP32'deki gibi ayrı set, clear ve XOR register'ları bulunur; machine.mem32 ile bunlara doğrudan yazabilirsin. Aşağıdaki kod, Pico'nun GP25'teki dahili LED'ini XOR register'ıyla yakıp söndürür (Pico W'de dahili LED Wi-Fi yongasına bağlıdır, orada harici bir LED kullan).
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)Bit işlemleriyle proje fikirleri
- İkilik sayaç: 8 LED'de 0'dan 255'e sayan bir sayaç yap ve ikilik sistemi gözünle gör; bir butonla bir artır, diğeriyle bir azalt.
- Karaşimşek efekti: Bir baytı << ve >> ile kaydırarak LED'leri git-gel yaktır; adım adım kurulum karaşimşek ve yürüyen LED yazısında.
- Dijital saat: Dört haneli 7 segment ekranda saati göster, ikinci hanenin noktasını her saniye 0x80 maskesiyle yakıp söndür.
- LED matris simgeleri: 8×8 matristeki her satırı bir bayt olarak çiz; kalp, ok ya da harfleri 0b ile tasarla. MAX7219 LED matris yazısı bu yöntemi kullanır.
- Ayar bayrakları: Ses açık, ekran parlak, alarm kurulu gibi açık/kapalı ayarları tek bir baytın bitlerinde tutup EEPROM'a tek seferde yaz.
- DIP switch ile adres seçimi: 4 anahtarlı bir DIP switch'i okuyup 0–15 arası bir cihaz adresi elde et.
Sık yapılan hatalar ve çözümleri
| Hata | Ne olur? | Doğrusu |
|---|---|---|
| if (x & 0x04 == 0) | == önce hesaplanır, ifade x & 0 olur ve hep yanlış çıkar | if ((x & 0x04) == 0) |
| 2 ^ 3 ile üs almak | ^ XOR'dur; 2 ^ 3 = 1 | 1 << 3 ya da pow(2, 3) |
| Uno'da 1 << 15 ya da 1 << 20 | 16 bitlik int taşar: -32768 ya da 0 | 1UL << 20 (unsigned long) |
| Serial.println(x, BIN) çıktısını 8 bit sanmak | Baştaki sıfırlar yazılmaz: 12 → 1100 | bitRead ile döngüde 8 bit yazdır |
| Sayının başına 0 koymak (010) | Sekizlik sayı olur: 010 = 8 | Onluk sayılarda baştaki sıfırı kaldır |
| ~ sonucunu int'te kullanmak | Üst bitler de terslenir: ~0x0F = -16 | Sonucu byte'a ata ya da & 0xFF ile maskele |
| & yerine && yazmak | İki koşul karşılaştırılır, bitler değil | Bitler için tek &, koşullar için && |
İkilik ve onaltılık sayılarla bit işlemleri ilk bakışta soyut görünür, ama bir LED dizisini tek bir baytla yönetmekten sensör verisini birleştirmeye kadar elektronikte her gün karşına çıkar. Arduino programlama temelleri ile birlikte öğrendiğinde kodun hem kısalır hem hızlanır. BlueGrays uygulamasında 7 segment sayaçlar, dijital saat, yürüyen LED, karaşimşek ve LED matris projelerini adım adım devre şeması ve bu bit işlemleriyle yazılmış kodlarıyla inceleyebilirsin.
Sıkça sorulan sorular
İkilik sayı sistemi nedir?
İkilik sayı sistemi yalnızca 0 ve 1 rakamlarını kullanan, her basamağı bir öncekinin iki katı değer taşıyan sayı sistemidir. Basamak değerleri sağdan sola 1, 2, 4, 8, 16, 32, 64, 128 diye gider. Dijital devrelerde 1 yüksek gerilimi, 0 düşük gerilimi temsil ettiği için bütün bilgisayarlar ve mikrodenetleyiciler bu sistemle çalışır.
Onluk sayı ikiliğe nasıl çevrilir?
Sayıyı 0 olana kadar sürekli 2'ye bölüp her adımdaki kalanı yazarsın; kalanları aşağıdan yukarı okuduğunda ikilik sayıyı elde edersin. Örneğin 13: 6 kalan 1, 3 kalan 0, 1 kalan 1, 0 kalan 1 ve sonuç 1101'dir. Kontrol etmek için 1 olan basamakların değerlerini toplarsın: 8 + 4 + 1 = 13.
Onaltılık (hex) sayı sistemi neden kullanılır?
Her hex rakamı tam olarak 4 bite karşılık geldiği için uzun ikilik sayıları kısa ve hatasız yazmanın en kolay yoludur. 8 bitlik bir bayt iki hex rakamıyla, örneğin 10110101 yerine B5 diye yazılır. I2C adresleri, renk kodları, register değerleri ve bellek adresleri bu yüzden hep hex ile verilir.
Arduino'da 0b ve 0x ne demek?
0b ile başlayan sayılar ikilik, 0x ile başlayanlar onaltılık olarak yorumlanır; 0b10110101, 0xB5 ve 181 aynı sayıdır. Hangisini yazdığın derleyici için fark etmez, yalnızca okunabilirliği etkiler. Arduino eski kodlar için 8 bitlik B10110101 biçimini de tanır.
bitRead ve bitWrite ne işe yarar?
bitRead(x, n), x sayısının n numaralı bitini 0 ya da 1 olarak döndürür; bitWrite(x, n, v) aynı biti v değerine ayarlar. bitSet ve bitClear de biti doğrudan 1 ya da 0 yapar. Bu fonksiyonlar maske ve kaydırma işlemlerini okunur hâle getirir; bit numaraları 0'dan başlar.
Arduino'da << ve >> operatörleri ne yapar?
<< bitleri sola kaydırır ve her adımda sayıyı 2 ile çarpar; >> bitleri sağa kaydırır ve her adımda 2'ye böler. 1 << 3 sonucu 8'dir ve tek bir biti seçen maskeler bu yolla oluşturulur. Uno'da int 16 bit olduğu için 15'ten büyük kaydırmalarda 1UL << n yazmak gerekir.
Bu yazıdan sonra yapabileceğin projeler
Tüm projeleri gör
Yürüyen Led
Sıra sıra yanıp sönen, koşar gibi ilerleyen ışıklar. Arduino altı LED'i tek tek yakar; her biri kısa bir an parlayıp söner ve ışık baştan sona yürür, sonra yeniden başlar.

Karaşimşek Led
Karaşimşek ışığı adıyla bilinen efekt: ışık altı LED'in üzerinde bir uçtan öbür uca kayar, sonra geri döner.

7 Segment Display İle 0-9 Sayı Yazdırma
Asansörlerdeki ve dijital saatlerdeki o bildik rakamları kendin yazdır. Yedi küçük ışık çubuğundan oluşan göstergede Arduino 0'dan 9'a kadar her saniye bir rakam gösterir, sonra yeniden başlar.

7 Segment Display İle 0-99 Sayı Yazdırma
Hesap makinelerindeki gibi çubuklardan oluşan iki rakamlık bir gösterge 0'dan 99'a kadar sayar.

4'lü 7 Segment Display'e 0-9999 Sayı Yazdırma
Dört haneli rakam ekranında sayılar 0'dan 9999'a kadar hızla akar, sonra yeniden sıfırdan başlar.

4'lü 7 Segment Display İle Dijital Saat
Mutfaktaki fırın saatine benzeyen dört haneli, ışıklı bir dijital saat. DS1302 saat modülü zamanı tutar, Arduino her saniye saati ve dakikayı okuyup dört rakamlık göstergeye yazar; saatle dakika…

Dot Matrix Saat ve Takvim (MAX7219, DS1307)
Masada ya da duvarda duran, saati ve tarihi kayan yazıyla gösteren ışıklı bir pano.

Piksel Yılan: 8x8 Matris
Klasik yılan oyununu kendi ellerinle kur ve oyna. Renkli 8x8 ışık matrisinde yeşil yılanı oyun çubuğuyla yönlendirip kırmızı elmaları yersin; her elmada yılan uzar, biraz daha hızlanır ve puanın…
Diğer yazılar
BlueGrays uygulaması
Bu devreyi telefonunda adım adım kur
Devre şeması, kod ve parça listesi tek ekranda. 500'den fazla Arduino, ESP32 ve Pico projesi seni bekliyor.
Telefonunla tara
Kamerayı koda tut; telefonunun uygulama mağazası açılır.
ya da mağazada aç

