İkilik say sistemi: binary, hex və Arduino-da bit əməliyyatları
İkilik say sistemi, onaltılıq və onluq çevirmələr, bit və bayt, Arduino-da 0b və 0x, &, |, ^, ~, <<, >> ilə bitRead, 74HC595 və register nümunələri.
İkilik say sistemi (binary) yalnız 0 və 1 rəqəmlərindən istifadə edən və bütün rəqəmsal elektronikanın əsasını təşkil edən say sistemidir. Arduino-nun hər pini, hər register-i və yaddaşdakı hər bayt əslində açıq və ya bağlı açarlardan ibarət ikilik ədəddir: 1 pinin HIGH, 0 isə LOW olması deməkdir. Kodda qarşına çıxan 0b10110101, 0xB5 və ya PORTB |= (1 << 5) kimi ifadələr qorxulu görünsə də, ikilik və onaltılıq sistemi bir dəfə anlayanda hamısı bir neçə sadə qaydaya gəlib çıxır.
Bu bələdçidə əvvəlcə onluq, ikilik və onaltılıq ədədləri bir-birinə əllə necə çevirəcəyini, bit, nibble və bayt anlayışlarını və mənfi ədədlərin yaddaşda necə saxlanıldığını görəcəksən. Sonra Arduino-da ədədləri 0b və 0x ilə yazmağı, AND, OR, XOR, NOT və sürüşdürmə əməliyyatları ilə tək bir biti oxumağı və dəyişməyi, bitRead, bitWrite və bitSet funksiyalarını öyrənəcəksən. Nəhayət, 7 seqmentli ekran və 74HC595 üçün bayt hazırlayacaq, Uno, ESP32 və Pico-da register-lərə birbaşa yazacaqsan.
Say sistemi nədir? Onluq, ikilik və onaltılıq
Gündəlik həyatda istifadə etdiyimiz onluq (decimal) sistemdə 10 rəqəm var və hər mərtəbə əvvəlkindən 10 dəfə çox dəyər daşıyır: 181 ədədi 1×100 + 8×10 + 1×1-dir. İkilik sistemdə yalnız iki rəqəm var və hər mərtəbə əvvəlkindən 2 dəfə çoxdur; sağdan sola mərtəbə dəyərləri 1, 2, 4, 8, 16, 32, 64, 128 kimi gedir. Onaltılıq (hexadecimal, qısaca hex) sistemdə isə 16 rəqəm var: 0–9-dan sonra A=10, B=11, C=12, D=13, E=14, F=15 gəlir. Hex-in elektronikada bu qədər sevilməsinin səbəbi hər hex rəqəminin tam olaraq 4 bitə uyğun gəlməsidir; uzun ikilik ədədləri qısa və oxunaqlı yazmağın ən praktik yoludur.
| Onluq | İkilik | Hex | Onluq | İ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 |
Çevirmələr: onluq, ikilik və hex arasında
Onluqdan ikiliyə çevirmək üçün ədədi ardıcıl olaraq 2-yə bölür və qalıqları qeyd edirsən; qalıqları aşağıdan yuxarıya oxuyanda ikilik ədəd alınır. 181 üçün: 181/2 = 90 qalıq 1, 90/2 = 45 qalıq 0, 45/2 = 22 qalıq 1, 22/2 = 11 qalıq 0, 11/2 = 5 qalıq 1, 5/2 = 2 qalıq 1, 2/2 = 1 qalıq 0, 1/2 = 0 qalıq 1. Aşağıdan yuxarı oxuyanda 10110101 alınır. İkilikdən onluğa qayıtmaq daha asandır: 1 olan mərtəbələrin dəyərlərini toplayırsan. 10110101 = 128 + 32 + 16 + 4 + 1 = 181.
| Mərtəbə dəyəri | 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 |
İkilikdən hex-ə çevirmək üçün bitləri sağdan başlayaraq dördlük qruplara ayırır və hər qrupu cədvəldəki hex rəqəmi ilə əvəz edirsən: 1011 0101 → B 5 → 0xB5. Tərs istiqamət də eyni dərəcədə asandır: 0x3C → 0011 1100. Hex-dən onluğa çevirmək üçün hər mərtəbəni 16-nın qüvvəsinə vurursan: 0xB5 = 11×16 + 5 = 181, 0x3FF = 3×256 + 15×16 + 15 = 1023. Son nümunə tanış gəlməlidir: Uno-nun 10 bitlik analogRead dəyərinin yuxarı həddi 1023-dür, yəni on dənə 1. Analoq oxuma ilə bit sayı arasındakı əlaqəni ADC yazısında tapa bilərsən.
Bit, nibble, bayt və dəyər aralıqları
Tək bir ikilik mərtəbəyə bit deyilir. 4 bit bir nibble, yəni tək bir hex rəqəmidir; 8 bit bir bayt (byte) edir və iki hex rəqəmi ilə yazılır. Baytdakı ən sağ bit ən kiçik dəyərli bit (LSB, bit 0), ən sol bit isə ən böyük dəyərli bitdir (MSB, bit 7). Bit nömrələri həmişə 0-dan başlayır; buna görə 8 bitlik ədədin bitləri 0–7 kimi nömrələnir. n bitlə 2ⁿ müxtəlif dəyər yazmaq olar: 8 bit 256, 10 bit 1024, 16 bit 65536 müxtəlif dəyər deməkdir.
| Ölçü | Arduino tipi | İşarəsiz aralıq | İşarəli aralıq |
|---|---|---|---|
| 8 bit (1 bayt) | byte, uint8_t / int8_t | 0–255 | -128 ilə 127 |
| 16 bit (2 bayt) | Uno-da int, word, uint16_t | 0–65535 | -32768 ilə 32767 |
| 32 bit (4 bayt) | long, uint32_t; ESP32 və Pico-da int | 0–4.294.967.295 | -2.147.483.648 ilə 2.147.483.647 |
Mənfi ədədlər: ikiyə tamamlayıcı
Mikrokontrollerlər mənfi ədədləri ikiyə tamamlayıcı (two's complement) üsulu ilə saxlayır: işarəli ədəddə ən sol bit 1-dirsə, ədəd mənfidir. Bir ədədin mənfisini tapmaq üçün bütün bitlərini tərsinə çevirir və 1 əlavə edirsən. 5 = 00000101; tərsi 11111010; 1 əlavə edəndə 11111011 = 0xFB, yəni -5. Eyni bit ardıcıllığı onu necə oxuduğundan asılı olaraq fərqli ədəddir: 0xFF byte kimi 255, int8_t kimi -1-dir. Buna görə sensordan gələn bayt xam datanı düzgün tipə mənimsətmək çox vacibdir. Dəyişən yuxarı həddi aşanda da yenidən başlayır: byte tipində 255 + 1 = 0, Uno-da int tipində 32767 + 1 = -32768 olur və buna daşma (overflow) deyilir.
Arduino-da 0b, 0x və B ilə ədəd yazmaq
Arduino kodunda eyni ədədi üç fərqli formada yaza bilərsən və kompilyator üçün heç bir fərqi yoxdur: 181 (onluq), 0b10110101 (ikilik, C++14-dən bəri standart) və 0xB5 (onaltılıq). Arduino həmçinin köhnə kodlardan qalan B10110101 formasını da tanıyır; amma bunlar yalnız 8 bitlik dəyərlər üçün təyin olunmuş sabitlərdir və yeni kodda 0b istifadə etmək daha yaxşıdır. Hansı formanın seçiləcəyi oxunaqlılıqdan asılıdır: LED naxışları və register ayarları üçün ikilik, ünvanlar və rəng kodları üçün hex, ölçmələr üçün onluq ən anlaşıqlı 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 əməliyyatları: &, |, ^, ~, << və >>
Bit əməliyyatları iki ədədin eyni sıradakı bitlərini tək-tək müqayisə edir. AND (&) yalnız hər iki bit 1-dirsə 1 verir; OR (|) bitlərdən biri 1-dirsə 1 verir; XOR (^) bitlər fərqlidirsə 1 verir; NOT (~) bütün bitləri tərsinə çevirir. Sola sürüşdürmə (<<) bitləri sola itələyir və sağdan 0 əlavə edir, hər addımda ədəd 2-yə vurulur; sağa sürüşdürmə (>>) bitləri sağa itələyir, hər addımda ədəd 2-yə bölünür. Bunlar məntiq elementlərinin proqramdakı qarşılığıdır; doğruluq cədvəllərini məntiq qapıları yazısında və məntiq qapısı alətində görə bilərsən. Aşağıdakı cədvəldə a = 0b11001010 (202) və b = 0b10101100 (172) üçün nəticələr var:
| Əməliyyat | Nə edir? | Nəticə (ikilik) | Hex | Onluq |
|---|---|---|---|---|
| a & b | İkisi də 1 olan bitlər | 10001000 | 0x88 | 136 |
| a | b | Ən azı biri 1 olan bitlər | 11101110 | 0xEE | 238 |
| a ^ b | Fərqli olan bitlər | 01100110 | 0x66 | 102 |
| ~a (byte) | Bütün bitlər tərsinə çevrilir | 00110101 | 0x35 | 53 |
| a << 1 (byte) | Bir mərtəbə sola, soldakı bit düşür | 10010100 | 0x94 | 148 |
| a >> 2 | İki mərtəbə sağa, sağdakı iki bit düşür | 00110010 | 0x32 | 50 |
Cədvəldə iki təfərrüata diqqət et. a << 1 nəticəsi byte dəyişəninə yazılanda ən sol bit kənara düşür və 148 qalır; eyni əməliyyat int-də aparılsa 404 olur, çünki int-də daşan bit üçün yer var. ~a da buna bənzəyir: byte kimi 53-dür, amma int kimi hesablananda yuxarı bitlər də tərsinə çevrilir və -203 alınır. Bit əməliyyatlarında nəticəni hansı tipdə saxladığını həmişə bilməlisən. & ilə &&-i də qarışdırma: birincisi bitləri tək-tək işləyir, ikincisi iki şərtin doğru olub-olmadığına baxır.
Bit maskaları: tək bir biti oxumaq, yandırmaq, söndürmək
Real layihələrdə bit əməliyyatları demək olar ki, həmişə maska ilə istifadə olunur. Maska yalnız maraqlandığın bitləri 1 olan ədəddir və adətən (1 << n) ilə yaradılır: (1 << 3) = 0b00001000. Bu maska ilə dörd əsas əməliyyat aparılır və Arduino hər biri üçün hazır funksiya da təqdim edir. Aşağıdakı kod 8 LED-in vəziyyətini 8 ayrı bool dəyişəni əvəzinə tək bir baytda saxlayır və D2–D9-dakı LED-lərə əks etdirir:
| Məqsəd | Maska ilə | Arduino funksiyası | Nümunə (n = 3) |
|---|---|---|---|
| Biti 1 et (set) | x |= (1 << n); | bitSet(x, n); | 00000000 → 00001000 |
| Biti 0 et (clear) | x &= ~(1 << n); | bitClear(x, n); | 11111111 → 11110111 |
| Biti tərsinə çevir (toggle) | x ^= (1 << n); | bitWrite(x, n, !bitRead(x, n)); | 00001000 → 00000000 |
| Biti oxu (test) | (x >> n) & 1 | bitRead(x, n); | 00001000 → 1 |
| Bitə verilən dəyəri yaz | x = (x & ~(1 << n)) | (v << n); | bitWrite(x, n, v); | v = 1 → 00001000 |
| n-ci bitin dəyəri | 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 seqmentli ekran üçün bayt hazırlamaq
7 seqmentli ekranın səkkiz hissəsi (a–g seqmentləri və nöqtə) tam olaraq bir bayta sığır. Bit 0-ı a seqmentinə, bit 6-nı g seqmentinə, bit 7-ni nöqtəyə (DP) təyin etsən, hər rəqəm tək bir ədədlə ifadə olunur. Məsələn, 2 rəqəmi a, b, d, e və g seqmentləri ilə çəkilir: 1 + 2 + 8 + 16 + 64 = 91 = 0x5B. Ümumi anodlu ekranlarda seqment LOW ilə yandığı üçün eyni cədvəli ~ ilə tərsinə çevirib istifadə edirsən. Seqment qoşulmalarının təfərrüatları üçün 7 seqmentli display yazısına baxa bilərsən.
| Rəqəm | Yanan seqmentlər | İkilik (DP g f e d c b a) | Ümumi katod | Ümumi anod (~) |
|---|---|---|---|---|
| 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 ilə baytı çıxışlara göndərmək
74HC595 sürüşdürmə registri baytı yalnız üç pinlə səkkiz çıxışa paylayır və bit əməliyyatlarını ən aydın gördüyün mikrosxemdir: göndərdiyin baytın hər biti bir çıxışı yandırır və ya söndürür. shiftOut funksiyası MSBFIRST ilə istifadə olunanda bit 7 əvvəl göndərilir və sonda Q7-yə yerləşir; bit 0 isə Q0-a düşür. Buna görə Q0-ı a seqmentinə, Q6-nı g-yə, Q7-ni DP-yə qoşsan, yuxarıdakı cədvəl birbaşa işləyir. Mikrosxemin bütün pinləri və zəncirvari qoşulması üçün 74HC595 shift register yazısına nəzər sal.
| Qoşulma | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| DS (14), ardıcıl data | 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 seqmentləri / DP, hər biri rezistorla | Eyni | Eyni |
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-ə birbaşa yazmaq: PORTB və DDRB
Uno-dakı ATmega328P-də pinlər 8-lik qruplar şəklində portlara bölünüb və hər portun üç register-i var: DDRx pinin istiqamətini (1 = çıxış), PORTx çıxış səviyyəsini, PINx isə oxunan səviyyəni saxlayır. D8–D13 pinləri B portundadır; D13 (daxili LED) PB5-dir, yəni PORTB-nin 5-ci bitidir. pinMode və digitalWrite əslində bu bitləri dəyişir, amma əvvəlcə pin nömrəsini porta çevirdiyi üçün bir neçə mikrosaniyə çəkir. Register-ə birbaşa yazmaq tək bir maşın komandasıdır və 16 MHz-də 2 saat tsiklində, yəni təxminən 125 nanosaniyəyə başa çatır. Həmçinin eyni portdakı bir neçə pini tam eyni anda dəyişməyə imkan verir.
| Uno pini | Port və bit | Uno pini | Port və bit |
|---|---|---|---|
| D0–D7 | PD0–PD7 (PORTD) | D8–D13 | PB0–PB5 (PORTB) |
| A0–A5 | PC0–PC5 (PORTC) | D13 (daxili 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-də register ilə pin idarə etmək
ESP32-də pinlər 32 bitlik register-lərlə idarə olunur və AVR-dən fərqli olaraq ayrıca set və clear register-ləri var: GPIO_OUT_W1TS_REG-ə (write 1 to set) yazdığın hər 1 biti müvafiq pini HIGH edir, GPIO_OUT_W1TC_REG-ə (write 1 to clear) yazdığın hər 1 biti LOW edir; 0 olan bitlər heç bir pinə toxunmur. Bu quruluş oxu-dəyiş-yaz tələb etmədiyi üçün kəsmələr və iki nüvə arasında təhlükəsizdir. Bu iki register yalnız GPIO 0–31-i əhatə edir; 32 və yuxarısı üçün GPIO_OUT1 register-ləri istifadə olunur.
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}Sensor datasını birləşdirmək və bölmək
I2C və SPI sensorları 16 bitlik ölçmələri adətən iki ayrı bayt kimi göndərir: əvvəl yüksək bayt (MSB), sonra aşağı bayt (LSB). Onları birləşdirmək üçün yüksək baytı 8 mərtəbə sola sürüşdürüb aşağı bayt ilə OR edirsən: int16_t ham = (msb << 8) | lsb;. Məsələn, təcil sensoru 0xFC və 0x18 göndərsə, nəticə 0xFC18-dir; int16_t kimi oxunanda ən sol bit 1 olduğu üçün bu ədəd -1000-dir. Əks istiqamətdə ədədi göndərmək və ya EEPROM-a yazmaq üçün highByte(x) və lowByte(x), iki baytı birləşdirmək üçün isə word(yuksek, dusuk) funksiyaları da var. I2C rabitəsinin özünü I2C nədir? yazısında, iki baytlıq xam data ilə işləyən sensoru MPU6050 yazısında görə bilərsən.
| İfadə | Nəticə | İzah |
|---|---|---|
| (0xFC << 8) | 0x18 | 0xFC18 | İki baytı tək 16 bitlik ədəddə birləşdirir |
| (int16_t)0xFC18 | -1000 | Ən sol bit 1 olduğu üçün işarəli oxumada mənfi |
| highByte(1000) | 0x03 | 1000 = 0x03E8; yüksək bayt |
| lowByte(1000) | 0xE8 | Aşağı bayt (232) |
| word(0x03, 0xE8) | 1000 | İki baytı yenidən birləşdirir |
| (durum >> 4) & 0x0F | Yuxarı nibble | Baytın yuxarı 4 bitini ayırır (məs., register sahəsi) |
Raspberry Pi Pico və MicroPython-da bitlər
MicroPython-da da eyni operatorlar keçərlidir; əlavə olaraq çevirmə üçün hazır funksiyalar var: bin(), hex() və int(mətn, əsas). Python-un tam ədədləri məhdudiyyətsiz böyüdüyü üçün ~ və << nəticələrini bir bayta sığdırmaq istəyirsənsə, & 0xFF ilə maskalamalısan. Pico-nun RP2040 çipində də ESP32-dəki kimi ayrıca set, clear və XOR register-ləri var; machine.mem32 ilə onlara birbaşa yaza bilərsən. Aşağıdakı kod Pico-nun GP25-dəki daxili LED-ini XOR register-i ilə yandırıb söndürür (Pico W-də daxili LED Wi-Fi çipinə qoşulub, orada xarici LED istifadə et).
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 əməliyyatları ilə layihə ideyaları
- İkilik sayğac: 8 LED-də 0-dan 255-ə qədər sayan sayğac düzəlt və ikilik sistemi gözünlə gör; bir düymə ilə bir artır, digəri ilə bir azalt.
- Qaçan işıq effekti (Knight Rider): Baytı << və >> ilə sürüşdürərək LED-ləri irəli-geri yandır; addım-addım quraşdırma qaçan işıq və yürüyən LED yazısındadır.
- Rəqəmsal saat: Dörd rəqəmli 7 seqmentli ekranda saatı göstər, ikinci rəqəmin nöqtəsini hər saniyə 0x80 maskası ilə yandırıb söndür.
- LED matris simvolları: 8×8 matrisdəki hər sətri bir bayt kimi çək; ürək, ox və ya hərfləri 0b ilə dizayn et. MAX7219 LED matris yazısı bu üsuldan istifadə edir.
- Ayar bayraqları: Səs açıq, ekran parlaq, siqnal qurulu kimi açıq/bağlı ayarları tək bir baytın bitlərində saxla və EEPROM-a bir dəfəyə yaz.
- DIP switch ilə ünvan seçimi: 4 açarlı DIP switch-i oxuyub 0–15 arası cihaz ünvanı əldə et.
Tez-tez edilən səhvlər və həlləri
| Səhv | Nə olur? | Düzgünü |
|---|---|---|
| if (x & 0x04 == 0) | == əvvəl hesablanır, ifadə x & 0 olur və həmişə yalan çıxır | if ((x & 0x04) == 0) |
| Qüvvət almaq üçün 2 ^ 3 yazmaq | ^ XOR-dur; 2 ^ 3 = 1 | 1 << 3 ya da pow(2, 3) |
| Uno-da 1 << 15 ya da 1 << 20 | 16 bitlik int daşır: -32768 ya da 0 | 1UL << 20 (unsigned long) |
| Serial.println(x, BIN) çıxışını 8 bit zənn etmək | Baş sıfırlar yazılmır: 12 → 1100 | bitRead ilə dövrdə 8 biti çap et |
| Ədədin əvvəlinə 0 qoymaq (010) | Səkkizlik ədəd olur: 010 = 8 | Onluq ədədlərdə baş sıfırı sil |
| ~ nəticəsini int-də istifadə etmək | Yuxarı bitlər də tərsinə çevrilir: ~0x0F = -16 | Nəticəni byte-a mənimsət ya da & 0xFF ilə maskala |
| & əvəzinə && yazmaq | İki şərt müqayisə olunur, bitlər yox | Bitlər üçün tək &, şərtlər üçün && |
İkilik və onaltılıq ədədlər və bit əməliyyatları ilk baxışda mücərrəd görünür, amma LED sırasını tək bir baytla idarə etməkdən sensor datasını birləşdirməyə qədər elektronikada hər gün qarşına çıxır. Arduino proqramlaşdırma əsasları ilə birlikdə öyrənəndə kodun həm qısalır, həm sürətlənir. BlueGrays tətbiqində 7 seqmentli sayğaclar, rəqəmsal saat, yürüyən LED, qaçan işıq və LED matris layihələrini addım-addım dövrə sxemi və bu bit əməliyyatları ilə yazılmış kodları ilə öyrənə bilərsən.
Tez-tez verilən suallar
İkilik say sistemi nədir?
İkilik say sistemi yalnız 0 və 1 rəqəmlərindən istifadə edən, hər mərtəbəsi əvvəlkindən iki dəfə çox dəyər daşıyan say sistemidir. Mərtəbə dəyərləri sağdan sola 1, 2, 4, 8, 16, 32, 64, 128 kimi gedir. Rəqəmsal dövrələrdə 1 yüksək gərginliyi, 0 aşağı gərginliyi təmsil etdiyi üçün bütün kompüterlər və mikrokontrollerlər bu sistemlə işləyir.
Onluq ədəd ikiliyə necə çevrilir?
Ədədi 0 olanadək ardıcıl 2-yə bölür və hər addımdakı qalığı yazırsan; qalıqları aşağıdan yuxarı oxuyanda ikilik ədədi alırsan. Məsələn, 13: 6 qalıq 1, 3 qalıq 0, 1 qalıq 1, 0 qalıq 1 və nəticə 1101-dir. Yoxlamaq üçün 1 olan mərtəbələrin dəyərlərini toplayırsan: 8 + 4 + 1 = 13.
Onaltılıq (hex) say sistemi niyə istifadə olunur?
Hər hex rəqəmi tam olaraq 4 bitə uyğun gəldiyi üçün uzun ikilik ədədləri qısa və xətasız yazmağın ən asan yoludur. 8 bitlik bayt iki hex rəqəmi ilə, məsələn, 10110101 əvəzinə B5 kimi yazılır. I2C ünvanları, rəng kodları, register dəyərləri və yaddaş ünvanları buna görə həmişə hex ilə verilir.
Arduino-da 0b və 0x nə deməkdir?
0b ilə başlayan ədədlər ikilik, 0x ilə başlayanlar onaltılıq kimi şərh olunur; 0b10110101, 0xB5 və 181 eyni ədəddir. Hansını yazmağın kompilyator üçün fərqi yoxdur, yalnız oxunaqlılığa təsir edir. Arduino köhnə kodlar üçün 8 bitlik B10110101 formasını da tanıyır.
bitRead və bitWrite nəyə lazımdır?
bitRead(x, n) x ədədinin n nömrəli bitini 0 ya da 1 kimi qaytarır; bitWrite(x, n, v) eyni biti v dəyərinə təyin edir. bitSet və bitClear da biti birbaşa 1 ya da 0 edir. Bu funksiyalar maska və sürüşdürmə əməliyyatlarını oxunaqlı edir; bit nömrələri 0-dan başlayır.
Arduino-da << və >> operatorları nə edir?
<< bitləri sola sürüşdürür və hər addımda ədədi 2-yə vurur; >> bitləri sağa sürüşdürür və hər addımda 2-yə bölür. 1 << 3 nəticəsi 8-dir və tək bir biti seçən maskalar bu yolla yaradılır. Uno-da int 16 bit olduğu üçün 15-dən böyük sürüşdürmələrdə 1UL << n yazmaq lazımdır.
Bu yazıdan sonra edə biləcəyin layihələr
Bütün layihələrə bax
Qaçan LED
Sıra ilə yanıb-sönən, qaça-qaça irəliləyən işıqlar. Arduino altı LED-i tək-tək yandırır; hər biri qısa an parlayıb sönür və işıq başdan sona qaçır, sonra yenidən başlayır.

Qaçan işıq LED
Knight Rider işığı kimi tanınan effekt: işıq altı LED üzərində bir ucdan o biri uca sürüşür, sonra geri qayıdır.

7 seqmentli displeydə 0-9 rəqəm yazdırma
Liftlərdəki və rəqəmsal saatlardakı o tanış rəqəmləri özün yazdır. Yeddi kiçik işıq çubuğundan ibarət göstəricidə Arduino 0-dan 9-a qədər hər saniyə bir rəqəm göstərir, sonra yenidən başlayır.

7 seqmentli displeydə 0-99 say yazdırma
Kalkulyatorlardakı kimi çubuqlardan ibarət iki rəqəmli göstərici 0-dan 99-a qədər sayır.

4 rəqəmli 7 seqmentli displeydə 0-9999 say yazdırma
Dörd rəqəmli ekranda ədədlər 0-dan 9999-a qədər sürətlə axır, sonra yenidən sıfırdan başlayır.

4 rəqəmli 7 seqmentli displeylə rəqəmsal saat
Mətbəxdəki soba saatına bənzəyən dörd rəqəmli, işıqlı rəqəmsal saat. DS1302 saat modulu vaxtı saxlayır, Arduino hər saniyə saatı və dəqiqəni oxuyub dörd rəqəmli göstəriciyə yazır; saatla dəqiqə…

Dot matrix saat və təqvim (MAX7219, DS1307)
Masada və ya divarda duran, saatı və tarixi sürüşən yazı ilə göstərən işıqlı lövhədir.

Piksel ilan: 8x8 matris
Klassik ilan oyununu özün qur və oyna. Rəngli 8x8 işıq matrisində yaşıl ilanı coystiklə idarə edib qırmızı almaları yeyirsən; hər almada ilan uzanır, bir az sürətlənir və xalın kiçik rəqəm ekranında…
Digər yazılar
BlueGrays tətbiqi
Bu dövrəni telefonunda addım-addım qur
Dövrə sxemi, kod və hissə siyahısı bir ekranda. 500-dən çox Arduino, ESP32 və Pico layihəsi səni gözləyir.
Telefonunla skan et
Kameranı koda tut; telefonunun tətbiq mağazası açılır.
ya da mağazada aç

