Əsaslar · 10 dəq oxu

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

Ç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əri1286432168421
10110101 (181)10110101
00001100 (12)00001100
11111111 (255)11111111

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

Kompüterindəki kalkulyatorun proqramçı rejimi və Arduino-nun Serial Monitor-u çevirmələri yoxlamağın ən sürətli yoludur. Serial.println(181, BIN) 10110101, Serial.println(181, HEX) isə B5 yazır. Çevirməni əllə bir neçə dəfə etmək isə register cədvəllərini və datasheet-ləri oxuyanda böyük asanlıq yaradır.

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_t0–255-128 ilə 127
16 bit (2 bayt)Uno-da int, word, uint16_t0–65535-32768 ilə 32767
32 bit (4 bayt)long, uint32_t; ESP32 və Pico-da int0–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.

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}
C++-da ədədin əvvəlinə sıfır qoymaq onu səkkizlik (octal) ədəd edir: 010 on deyil, səkkizdir, 0255 isə 173-dür. Pin nömrələrini və ya saatları hizalamaq üçün 08 ya da 09 yazsan, kompilyator xəta verir, 010 yazsan heç bir xəbərdarlıq vermədən səhv işləyir. Onluq ədədlərin əvvəlinə heç vaxt sıfır qoyma.

Bit əməliyyatları: &, |, ^, ~, &lt;&lt; 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əliyyatNə edir?Nəticə (ikilik)HexOnluq
a & bİkisi də 1 olan bitlər100010000x88136
a | bƏn azı biri 1 olan bitlər111011100xEE238
a ^ bFərqli olan bitlər011001100x66102
~a (byte)Bütün bitlər tərsinə çevrilir001101010x3553
a << 1 (byte)Bir mərtəbə sola, soldakı bit düşür100101000x94148
a >> 2İki mərtəbə sağa, sağdakı iki bit düşür001100100x3250

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ədMaska 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) & 1bitRead(x, n);00001000 → 1
Bitə verilən dəyəri yazx = (x & ~(1 << n)) | (v << n);bitWrite(x, n, v);v = 1 → 00001000
n-ci bitin dəyəri1 << 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 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əmYanan seqmentlərİkilik (DP g f e d c b a)Ümumi katodÜmumi anod (~)
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 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şulmaArduino UnoESP32Raspberry Pi Pico
DS (14), ardıcıl dataD11GPIO 23GP19
SH_CP (11), saatD13GPIO 18GP18
ST_CP (12), latchD10GPIO 5GP17
OE (13) / MR (10)GND / 5VGND / 3V3GND / 3V3(OUT)
Q0–Q6 / Q7a–g seqmentləri / DP, hər biri rezistorlaEyniEyni
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-ə 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 piniPort və bitUno piniPort və bit
D0–D7PD0–PD7 (PORTD)D8–D13PB0–PB5 (PORTB)
A0–A5PC0–PC5 (PORTC)D13 (daxili 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 plataya xasdır: Uno-da işləyən PORTB sətri Mega-da başqa pinləri idarə edir, ESP32 və Pico-da isə heç nəyi idarə etmir və hətta kompilyasiya olunmur. Bundan əlavə, PORTD-nin 0 və 1 nömrəli bitləri serial port pinləridir; PORTD = 0xFF kimi bütün portu birdən yazan sətir Serial-ı pozabilər. Portun yalnız maraqlandığın bitlərini maska ilə dəyiş və register kodunu yalnız sürətin həqiqətən vacib olduğu yerlərdə istifadə et.

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.

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}

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) | 0x180xFC18İ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)0x031000 = 0x03E8; yüksək bayt
lowByte(1000)0xE8Aşağı bayt (232)
word(0x03, 0xE8)1000İki baytı yenidən birləşdirir
(durum >> 4) & 0x0FYuxarı nibbleBaytı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).

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 ə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əhvNə olur?Düzgünü
if (x & 0x04 == 0)== əvvəl hesablanır, ifadə x & 0 olur və həmişə yalan çıxırif ((x & 0x04) == 0)
Qüvvət almaq üçün 2 ^ 3 yazmaq^ XOR-dur; 2 ^ 3 = 11 << 3 ya da pow(2, 3)
Uno-da 1 << 15 ya da 1 << 2016 bitlik int daşır: -32768 ya da 01UL << 20 (unsigned long)
Serial.println(x, BIN) çıxışını 8 bit zənn etməkBaş sıfırlar yazılmır: 12 → 1100bitRead ilə dövrdə 8 biti çap et
Ədədin əvvəlinə 0 qoymaq (010)Səkkizlik ədəd olur: 010 = 8Onluq ədədlərdə baş sıfırı sil
~ nəticəsini int-də istifadə etməkYuxarı bitlər də tərsinə çevrilir: ~0x0F = -16Nəticəni byte-a mənimsət ya da & 0xFF ilə maskala
& əvəzinə && yazmaqİki şərt müqayisə olunur, bitlər yoxBitlər üçün tək &, şərtlər üçün &&
Bit əməliyyatından əmin deyilsənsə, nəticəni üç formada çap et: Serial.println(x), Serial.println(x, BIN) və Serial.println(x, HEX). Eyni dəyəri onluq, ikilik və onaltılıq görmək maskanın və ya sürüşdürmənin gözlədiyin bitlərə toxunub-toxunmadığını dərhal göstərir.

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

Bütün layihələrə bax
Qaçan LED
AR-5Orta

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.

4.6(87)
217
Qaçan işıq LED
AR-6Orta

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.

4.8(107)
214
7 seqmentli displeydə 0-9 rəqəm yazdırma
AR-41Orta
Premium

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.

4.5(30)
43
7 seqmentli displeydə 0-99 say yazdırma
AR-42Qabaqcıl
Premium

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.5(27)
35
4 rəqəmli 7 seqmentli displeydə 0-9999 say yazdırma
AR-47Orta
Premium

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.4(19)
25
4 rəqəmli 7 seqmentli displeylə rəqəmsal saat
AR-48Orta
Premium

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ə…

4.8(56)
73
Dot matrix saat və təqvim (MAX7219, DS1307)
AR-84Orta
Premium

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.

5.0(37)
59
Piksel ilan: 8x8 matris
AR-88Qabaqcıl
Premium

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…

4.7(39)
57