Temeller · 9 dk okuma

İ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İkilikHexOnlukİkilikHex
000000810008
100011910019
200102101010A
300113111011B
401004121100C
501015131101D
601106141110E
701117151111F

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ğeri1286432168421
10110101 (181)10110101
00001100 (12)00001100
11111111 (255)11111111

İ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.

Bilgisayarındaki hesap makinesinin programcı modu ve Arduino'nun Seri Monitörü dönüşümleri kontrol etmenin en hızlı yoludur. Serial.println(181, BIN) 10110101, Serial.println(181, HEX) B5 yazar. Elle dönüşümü birkaç kez yapman ise register tablolarını ve veri sayfalarını okurken büyük kolaylık sağlar.

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.

BoyutArduino türüİşaretsiz aralıkİşaretli aralık
8 bit (1 bayt)byte, uint8_t / int8_t0–255-128 ile 127
16 bit (2 bayt)Uno'da int, word, uint16_t0–65535-32768 ile 32767
32 bit (4 bayt)long, uint32_t; ESP32 ve Pico'da int0–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.

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}
Bir sayının başına sıfır koymak C++'ta onu sekizlik (octal) sayı yapar: 010 on değil sekizdir, 0255 ise 173'tür. Pin numaralarını ya da saatleri hizalamak için 08 ya da 09 yazarsan derleyici hata verir, 010 yazarsan hiçbir uyarı vermeden yanlış çalışır. Onluk sayıların başına asla sıfır koyma.

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:

İşlemNe yapar?Sonuç (ikilik)HexOnluk
a & bİkisi de 1 olan bitler100010000x88136
a | bEn az biri 1 olan bitler111011100xEE238
a ^ bFarklı olan bitler011001100x66102
~a (byte)Bütün bitler terslenir001101010x3553
a << 1 (byte)Bir basamak sola, soldaki bit düşer100101000x94148
a >> 2İki basamak sağa, sağdaki iki bit düşer001100100x3250

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çMaskeyleArduino 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) & 1bitRead(x, n);00001000 → 1
Biti verilen değere yazx = (x & ~(1 << n)) | (v << n);bitWrite(x, n, v);v = 1 → 00001000
n. bitin değeri1 << 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}

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.

RakamYanan segmentlerİkilik (DP g f e d c b a)Ortak katotOrtak anot (~)
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

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 UnoESP32Raspberry Pi Pico
DS (14), seri veriD11GPIO 23GP19
SH_CP (11), saatD13GPIO 18GP18
ST_CP (12), latchD10GPIO 5GP17
OE (13) / MR (10)GND / 5VGND / 3V3GND / 3V3(OUT)
Q0–Q6 / Q7a–g segmentleri / DP, her biri dirençleAynıAynı
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}

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 piniPort ve bitUno piniPort ve bit
D0–D7PD0–PD7 (PORTD)D8–D13PB0–PB5 (PORTB)
A0–A5PC0–PC5 (PORTC)D13 (dahili 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}
Register kodu karta özeldir: Uno'da çalışan PORTB satırı Mega'da başka pinleri, ESP32 ve Pico'da hiçbir şeyi kontrol etmez ve derlenmez bile. Ayrıca PORTD'nin 0 ve 1 numaralı bitleri seri port pinleridir; PORTD = 0xFF gibi bütün portu birden yazan bir satır Serial'ı bozabilir. Portun yalnızca ilgilendiğin bitlerini maskeyle değiştir ve register kodunu yalnızca hızın gerçekten önemli olduğu yerlerde kullan.

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.

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}

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.

İfadeSonuçAçıklama
(0xFC << 8) | 0x180xFC18İki baytı tek 16 bitlik sayıda birleştirir
(int16_t)0xFC18-1000En soldaki bit 1 olduğu için işaretli okumada negatif
highByte(1000)0x031000 = 0x03E8; yüksek bayt
lowByte(1000)0xE8Düşük bayt (232)
word(0x03, 0xE8)1000İki baytı yeniden birleştirir
(durum >> 4) & 0x0FÜst nibbleBir 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).

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)

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

HataNe olur?Doğrusu
if (x & 0x04 == 0)== önce hesaplanır, ifade x & 0 olur ve hep yanlış çıkarif ((x & 0x04) == 0)
2 ^ 3 ile üs almak^ XOR'dur; 2 ^ 3 = 11 << 3 ya da pow(2, 3)
Uno'da 1 << 15 ya da 1 << 2016 bitlik int taşar: -32768 ya da 01UL << 20 (unsigned long)
Serial.println(x, BIN) çıktısını 8 bit sanmakBaştaki sıfırlar yazılmaz: 12 → 1100bitRead ile döngüde 8 bit yazdır
Sayının başına 0 koymak (010)Sekizlik sayı olur: 010 = 8Onluk sayılarda baştaki sıfırı kaldır
~ sonucunu int'te kullanmakÜst bitler de terslenir: ~0x0F = -16Sonucu byte'a ata ya da & 0xFF ile maskele
& yerine && yazmakİki koşul karşılaştırılır, bitler değilBitler için tek &, koşullar için &&
Bir bit işleminden emin değilsen sonucu üç biçimde yazdır: Serial.println(x), Serial.println(x, BIN) ve Serial.println(x, HEX). Aynı değeri onluk, ikilik ve onaltılık görmek, maskenin ya da kaydırmanın beklediğin bitlere dokunup dokunmadığını hemen gösterir.

İ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.

Tüm projeleri gör
Yürüyen Led
AR-5Orta

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.

4.6(87)
218
Karaşimşek Led
AR-6Orta

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.

4.8(107)
214
7 Segment Display İle 0-9 Sayı Yazdırma
AR-41Orta
Premium

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.

4.5(30)
43
7 Segment Display İle 0-99 Sayı Yazdırma
AR-42İleri
Premium

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.5(27)
35
4'lü 7 Segment Display'e 0-9999 Sayı Yazdırma
AR-47Orta
Premium

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.4(19)
25
4'lü 7 Segment Display İle Dijital Saat
AR-48Orta
Premium

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…

4.8(56)
73
Dot Matrix Saat ve Takvim (MAX7219, DS1307)
AR-84Orta
Premium

Dot Matrix Saat ve Takvim (MAX7219, DS1307)

Masada ya da duvarda duran, saati ve tarihi kayan yazıyla gösteren ışıklı bir pano.

5.0(37)
59
Piksel Yılan: 8x8 Matris
AR-88İleri
Premium

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…

4.7(39)
57