Двоичная система счисления: hex, биты и побитовые операции на Arduino
Двоичная система счисления, перевод между hex и десятичными числами, биты и байты, 0b и 0x на Arduino, &, |, ^, ~, <<, >> и bitRead, примеры с 74HC595 и регистрами.
Двоичная система счисления использует только цифры 0 и 1 и лежит в основе всей цифровой электроники. Каждый пин, каждый регистр и каждый байт памяти Arduino — по сути двоичное число из включённых или выключенных переключателей: 1 означает уровень HIGH на пине, а 0 — LOW. Выражения, которые встречаются в коде, например 0b10110101, 0xB5 или PORTB |= (1 << 5), могут выглядеть пугающе, но после знакомства с двоичной и шестнадцатеричной системами всё сводится к нескольким простым правилам.
В этом руководстве ты сначала узнаешь, как вручную переводить десятичные, двоичные и шестнадцатеричные числа друг в друга, что такое биты, полубайты и байты и как отрицательные числа хранятся в памяти. Затем научишься записывать числа на Arduino с 0b и 0x, читать и менять отдельные биты операциями AND, OR, XOR, NOT и сдвигами, а также использовать функции bitRead, bitWrite и bitSet. В конце подготовишь байты для 7-сегментного индикатора и 74HC595 и запишешь данные прямо в регистры Uno, ESP32 и Pico.
Что такое система счисления? Десятичная, двоичная и шестнадцатеричная
В привычной десятичной системе 10 цифр, а вес каждого разряда в 10 раз больше предыдущего: 181 — это 1×100 + 8×10 + 1×1. В двоичной системе всего две цифры, а вес каждого разряда вдвое больше предыдущего; справа налево веса равны 1, 2, 4, 8, 16, 32, 64, 128. В шестнадцатеричной системе (сокращённо hex) 16 цифр: после 0–9 идут A=10, B=11, C=12, D=13, E=14, F=15. Hex так популярна в электронике, потому что каждая её цифра соответствует ровно 4 битам; это самый удобный способ коротко и понятно записывать длинные двоичные числа.
| Десятичное | Двоичное | Шестнадцатеричное | Десятичное | Двоичное | Шестнадцатеричное |
|---|---|---|---|---|---|
| 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 |
Перевод между десятичной, двоичной и шестнадцатеричной системами
Чтобы перевести число из десятичной системы в двоичную, последовательно дели его на 2 и записывай остатки; прочитав остатки снизу вверх, получишь двоичное число. Для 181: 181/2 = 90, остаток 1; 90/2 = 45, остаток 0; 45/2 = 22, остаток 1; 22/2 = 11, остаток 0; 11/2 = 5, остаток 1; 5/2 = 2, остаток 1; 2/2 = 1, остаток 0; 1/2 = 0, остаток 1. Снизу вверх получается 10110101. Перевести из двоичной системы в десятичную ещё проще: сложи веса разрядов, в которых стоит 1. 10110101 = 128 + 32 + 16 + 4 + 1 = 181.
| Вес разряда | 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 |
Чтобы перевести число из двоичной системы в hex, разбей биты на группы по четыре справа налево и замени каждую группу шестнадцатеричной цифрой из таблицы: 1011 0101 → B 5 → 0xB5. Обратно так же просто: 0x3C → 0011 1100. Для перевода из hex в десятичную систему умножь каждую цифру на соответствующую степень 16: 0xB5 = 11×16 + 5 = 181, 0x3FF = 3×256 + 15×16 + 15 = 1023. Последний пример наверняка знаком: верхний предел 10-битного значения analogRead на Uno — 1023, то есть десять единиц. Связь аналоговых измерений с числом битов разобрана в статье об АЦП.
Биты, полубайты, байты и диапазоны значений
Одна двоичная цифра называется битом. 4 бита образуют полубайт — одну шестнадцатеричную цифру; 8 бит образуют байт, который записывается двумя шестнадцатеричными цифрами. Крайний правый бит байта — младший значащий разряд (LSB, бит 0), а крайний левый — старший значащий разряд (MSB, бит 7). Нумерация битов всегда начинается с 0, поэтому биты 8-битного числа имеют номера 0–7. С помощью n бит можно записать 2ⁿ разных значений: 8 бит дают 256, 10 бит — 1 024, а 16 бит — 65 536 значений.
| Размер | Тип Arduino | Диапазон без знака | Диапазон со знаком |
|---|---|---|---|
| 8 бит (1 байт) | byte, uint8_t / int8_t | 0–255 | От -128 до 127 |
| 16 бит (2 байта) | int на Uno, word, uint16_t | 0–65535 | От -32 768 до 32 767 |
| 32 бита (4 байта) | long, uint32_t; int на ESP32 и Pico | 0–4 294 967 295 | От -2 147 483 648 до 2 147 483 647 |
Отрицательные числа: дополнительный код
Микроконтроллеры хранят отрицательные числа в дополнительном коде: если в знаковом числе крайний левый бит равен 1, число отрицательное. Чтобы получить противоположное число, инвертируй все его биты и прибавь 1. 5 = 00000101; после инверсии — 11111010; прибавь 1 и получишь 11111011 = 0xFB, то есть -5. Один и тот же набор битов означает разные числа в зависимости от способа чтения: 0xFF — это 255 в типе byte и -1 в типе int8_t. Поэтому так важно присваивать сырые байты датчика переменным правильного типа. При выходе за верхний предел значение переменной также переходит на другой край диапазона: для byte 255 + 1 = 0, а для int на Uno 32767 + 1 = -32768; это называется переполнением.
Запись чисел с 0b, 0x и B на Arduino
В коде Arduino одно и то же число можно записать тремя способами, и для компилятора разницы нет: 181 (десятичное), 0b10110101 (двоичное, стандарт начиная с C++14) и 0xB5 (шестнадцатеричное). Arduino также распознаёт оставшуюся от старого кода форму B10110101, но такие константы определены только для 8-битных значений, поэтому в новом коде лучше 0b. Выбор формы зависит от удобства чтения: двоичная запись нагляднее для узоров светодиодов и настроек регистров, hex — для адресов и кодов цветов, десятичная — для измерений.
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}Побитовые операции: &, |, ^, ~, << и >>
Побитовые операции последовательно сравнивают биты двух чисел на одинаковых позициях. AND (&), И даёт 1, только если оба бита равны 1; OR (|), ИЛИ даёт 1, если хотя бы один бит равен 1; XOR (^), исключающее ИЛИ даёт 1, если биты различаются; NOT (~), НЕ инвертирует каждый бит. Сдвиг влево (<<) сдвигает биты влево и добавляет справа нули, умножая число на 2 на каждом шаге; сдвиг вправо (>>) сдвигает биты вправо, деля число на 2 на каждом шаге. Это программные аналоги логических элементов; их таблицы истинности есть в статье логические элементы и в утилите логических элементов. Таблица ниже показывает результаты для a = 0b11001010 (202) и b = 0b10101100 (172):
| Операция | Что делает? | Результат (двоичный) | Шестнадцатеричный | Десятичный |
|---|---|---|---|---|
| a & b | Биты, равные 1 в обоих числах | 10001000 | 0x88 | 136 |
| a | b | Биты, равные 1 хотя бы в одном числе | 11101110 | 0xEE | 238 |
| a ^ b | Различающиеся биты | 01100110 | 0x66 | 102 |
| ~a (byte) | Все биты инвертированы | 00110101 | 0x35 | 53 |
| a << 1 (byte) | На одну позицию влево, крайний левый бит теряется | 10010100 | 0x94 | 148 |
| a >> 2 | На две позиции вправо, два крайних правых бита теряются | 00110010 | 0x32 | 50 |
Обрати внимание на две детали таблицы. Если результат a << 1 хранится в byte, крайний левый бит теряется и остаётся 148; в int та же операция даёт 404, потому что в int есть место для вышедшего за пределы байта бита. С ~a похожая ситуация: в byte это 53, но при вычислении в int старшие биты тоже инвертируются и результат равен -203. При побитовых операциях нужно всегда знать, какой тип хранит результат. И не путай & и &&: первый работает с отдельными битами, второй проверяет истинность двух условий.
Битовые маски: чтение, установка и сброс отдельного бита
В реальных проектах побитовые операции почти всегда используют с маской. Маска — это число, в котором единицами отмечены только нужные биты; обычно её создают выражением (1 << n): (1 << 3) = 0b00001000. С маской выполняют четыре основные операции, и для каждой Arduino предлагает готовую функцию. Код ниже хранит состояния 8 светодиодов в одном байте вместо 8 отдельных переменных bool и выводит их на светодиоды D2–D9:
| Задача | С маской | Функция Arduino | Пример (n = 3) |
|---|---|---|---|
| Установить бит в 1 | x |= (1 << n); | bitSet(x, n); | 00000000 → 00001000 |
| Сбросить бит в 0 | x &= ~(1 << n); | bitClear(x, n); | 11111111 → 11110111 |
| Переключить бит | x ^= (1 << n); | bitWrite(x, n, !bitRead(x, n)); | 00001000 → 00000000 |
| Прочитать (проверить) бит | (x >> n) & 1 | bitRead(x, n); | 00001000 → 1 |
| Записать заданное значение в бит | x = (x & ~(1 << n)) | (v << n); | bitWrite(x, n, v); | v = 1 → 00001000 |
| Вес бита n | 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-сегментного индикатора
Восемь частей 7-сегментного индикатора (сегменты a–g и десятичная точка) точно помещаются в один байт. Если назначить бит 0 сегменту a, бит 6 — сегменту g, а бит 7 — десятичной точке (DP), каждую цифру можно выразить одним числом. Например, цифру 2 образуют сегменты a, b, d, e и g: 1 + 2 + 8 + 16 + 64 = 91 = 0x5B. У индикаторов с общим анодом сегмент загорается при LOW, поэтому ту же таблицу инвертируют с помощью ~. Подробности подключения сегментов есть в статье 7-сегментный индикатор.
| Цифра | Горящие сегменты | Двоичное число (DP g f e d c b a) | Общий катод | Общий анод (~) |
|---|---|---|---|---|
| 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
Сдвиговый регистр 74HC595 распределяет один байт по восьми выходам, используя всего три пина, и на этой микросхеме побитовые операции особенно наглядны: каждый бит отправленного байта включает или выключает один выход. При использовании shiftOut с MSBFIRST первым отправляется бит 7 и попадает в Q7, а бит 0 — в Q0. Поэтому если подключить Q0 к сегменту a, Q6 к g, а Q7 к DP, таблица выше работает напрямую. Все пины микросхемы и соединение в цепочку разобраны в статье сдвиговый регистр 74HC595.
| Подключение | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| DS (14), последовательные данные | D11 | GPIO 23 | GP19 |
| SH_CP (11), тактовый сигнал | D13 | GPIO 18 | GP18 |
| ST_CP (12), защёлка | D10 | GPIO 5 | GP17 |
| OE (13) / MR (10) | GND / 5V | GND / 3V3 | GND / 3V3(OUT) |
| Q0–Q6 / Q7 | Сегменты a–g / DP, каждый через резистор | То же | То же |
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}Прямая запись в регистры: PORTB и DDRB
В ATmega328P на Uno пины объединены в 8-пиновые порты, и у каждого порта три регистра: DDRx хранит направление пина (1 = выход), PORTx — выходной уровень, а PINx — считываемый уровень. Пины D8–D13 относятся к порту B; D13 (встроенный светодиод) — это PB5, бит 5 регистра PORTB. pinMode и digitalWrite на самом деле меняют эти биты, но сначала переводят номер пина в порт, поэтому занимают несколько микросекунд. Прямая запись в регистр — одна машинная инструкция, которая выполняется за 2 такта при 16 MHz, примерно за 125 наносекунд. Она также позволяет менять несколько пинов одного порта строго одновременно.
| Пин Uno | Порт и бит | Пин Uno | Порт и бит |
|---|---|---|---|
| D0–D7 | PD0–PD7 (PORTD) | D8–D13 | PB0–PB5 (PORTB) |
| A0–A5 | PC0–PC5 (PORTC) | D13 (встроенный светодиод) | 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
На ESP32 пинами управляют 32-битные регистры, и, в отличие от AVR, есть отдельные регистры установки и сброса: каждый бит 1, записанный в GPIO_OUT_W1TS_REG (запись 1 для установки), переводит соответствующий пин в HIGH, а каждый бит 1, записанный в GPIO_OUT_W1TC_REG (запись 1 для сброса), — в LOW; нулевые биты не затрагивают пины. Поскольку операция не требует цикла чтение–изменение–запись, она безопасна при прерываниях и работе двух ядер. Эти два регистра охватывают только GPIO 0–31; для 32 и выше используются регистры GPIO_OUT1.
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}Объединение и разделение данных датчиков
Датчики I2C и SPI обычно передают 16-битные показания двумя отдельными байтами: сначала старший (MSB), затем младший (LSB). Чтобы объединить их, сдвинь старший байт на 8 позиций влево и выполни OR с младшим: int16_t raw = (msb << 8) | lsb;. Например, если акселерометр отправляет 0xFC и 0x18, результат — 0xFC18; при чтении как int16_t это -1000, потому что крайний левый бит равен 1. Для обратной задачи — отправки числа или записи в EEPROM — есть highByte(x) и lowByte(x), а для объединения двух байтов — word(high, low). Сам обмен по I2C разобран в статье что такое I2C?, а датчик с двухбайтовыми сырыми данными — в статье MPU6050.
| Выражение | Результат | Объяснение |
|---|---|---|
| (0xFC << 8) | 0x18 | 0xFC18 | Объединяет два байта в одно 16-битное число |
| (int16_t)0xFC18 | -1000 | При чтении со знаком число отрицательное, потому что крайний левый бит равен 1 |
| highByte(1000) | 0x03 | 1000 = 0x03E8; старший байт |
| lowByte(1000) | 0xE8 | Младший байт (232) |
| word(0x03, 0xE8) | 1000 | Снова объединяет два байта |
| (state >> 4) & 0x0F | Старший полубайт | Извлекает старшие 4 бита байта (например, поле регистра) |
Биты на Raspberry Pi Pico и в MicroPython
В MicroPython действуют те же операторы, а ещё есть готовые функции преобразования: bin(), hex() и int(text, base). Поскольку целые числа Python могут расти без ограничения, результаты ~ и << нужно маскировать с помощью & 0xFF, если они должны помещаться в байт. У микросхемы RP2040 на Pico, как и у ESP32, также есть отдельные регистры установки, сброса и XOR; в них можно писать напрямую через machine.mem32. Код ниже мигает встроенным светодиодом Pico на GP25 с помощью регистра XOR (на Pico W встроенный светодиод подключён к микросхеме Wi-Fi, поэтому там используй внешний светодиод).
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)Идеи проектов с побитовыми операциями
- Двоичный счётчик: собери счётчик от 0 до 255 на 8 светодиодах и увидишь двоичную систему своими глазами; одна кнопка прибавляет единицу, другая вычитает.
- Светодиодный эффект Knight Rider: сдвигай байт с помощью << и >>, чтобы огни двигались туда и обратно; пошаговая сборка есть в статье Knight Rider и бегущие огни на светодиодах.
- Цифровые часы: показывай время на четырёхразрядном 7-сегментном индикаторе и каждую секунду переключай десятичную точку второго разряда маской 0x80.
- Значки на светодиодной матрице: представь каждую строку матрицы 8×8 одним байтом; создавай сердечки, стрелки и буквы с 0b. Этот способ используется в статье светодиодная матрица MAX7219.
- Флаги настроек: храни настройки включения и выключения, например звук, яркий экран и установленный будильник, в битах одного байта и записывай их в EEPROM за один раз.
- Выбор адреса DIP-переключателем: считай 4-позиционный DIP-переключатель, чтобы получить адрес устройства от 0 до 15.
Частые ошибки и их решения
| Ошибка | Что происходит? | Правильный вариант |
|---|---|---|
| if (x & 0x04 == 0) | Сначала вычисляется ==, выражение превращается в x & 0 и всегда ложно | if ((x & 0x04) == 0) |
| Использование 2 ^ 3 для возведения в степень | ^ — это XOR; 2 ^ 3 = 1 | 1 << 3 или pow(2, 3) |
| 1 << 15 или 1 << 20 на Uno | 16-битный int переполняется: -32768 или 0 | 1UL << 20 (unsigned long) |
| Ожидание, что Serial.println(x, BIN) выводит 8 бит | Ведущие нули не выводятся: 12 → 1100 | Выводи 8 бит в цикле через bitRead |
| Ноль перед числом (010) | Число становится восьмеричным: 010 = 8 | Убери ведущие нули из десятичных чисел |
| Использование результата ~ в int | Старшие биты тоже инвертируются: ~0x0F = -16 | Присвой результат переменной byte или примени маску & 0xFF |
| Запись && вместо & | Сравниваются два условия, а не биты | Один & для битов, && для условий |
Двоичные и шестнадцатеричные числа и побитовые операции поначалу кажутся абстрактными, но в электронике они встречаются каждый день: от управления рядом светодиодов одним байтом до объединения данных датчика. Если изучать их вместе с основами программирования Arduino, код станет короче и быстрее. В приложении BlueGrays можно изучить проекты 7-сегментных счётчиков, цифровых часов, бегущих огней на светодиодах, светодиодного эффекта Knight Rider и светодиодных матриц с пошаговыми схемами и кодом, использующим эти побитовые операции.
Частые вопросы
Что такое двоичная система счисления?
Двоичная система счисления использует только цифры 0 и 1, а вес каждого разряда вдвое больше предыдущего. Справа налево веса разрядов равны 1, 2, 4, 8, 16, 32, 64, 128. Поскольку в цифровых схемах 1 обозначает высокое напряжение, а 0 — низкое, все компьютеры и микроконтроллеры работают в этой системе.
Как перевести десятичное число в двоичное?
Последовательно дели число на 2, пока не получится 0, и записывай остаток на каждом шаге; прочитав остатки снизу вверх, получишь двоичное число. Для 13: 6, остаток 1; 3, остаток 0; 1, остаток 1; 0, остаток 1, поэтому результат — 1101. Для проверки сложи веса разрядов с единицами: 8 + 4 + 1 = 13.
Зачем нужна шестнадцатеричная система (hex)?
Каждая шестнадцатеричная цифра соответствует ровно 4 битам, поэтому это самый простой способ коротко и без ошибок записывать длинные двоичные числа. 8-битный байт записывается двумя шестнадцатеричными цифрами, например B5 вместо 10110101. Поэтому адреса I2C, коды цветов, значения регистров и адреса памяти всегда указывают в hex.
Что означают 0b и 0x на Arduino?
Числа с префиксом 0b интерпретируются как двоичные, а с 0x — как шестнадцатеричные; 0b10110101, 0xB5 и 181 — одно и то же число. Выбор записи влияет только на удобство чтения, для компилятора разницы нет. Arduino также поддерживает 8-битную форму B10110101 из старого кода.
Что делают bitRead и bitWrite?
bitRead(x, n) возвращает бит числа x с номером n как 0 или 1; bitWrite(x, n, v) задаёт этому биту значение v. bitSet и bitClear напрямую устанавливают бит в 1 или 0. Эти функции делают операции с масками и сдвигами понятнее; нумерация битов начинается с 0.
Что делают операторы << и >> на Arduino?
<< сдвигает биты влево и на каждом шаге умножает число на 2; >> сдвигает их вправо и на каждом шаге делит на 2. 1 << 3 даёт 8; так создаются маски для выбора одного бита. Поскольку int на Uno занимает 16 бит, для сдвига больше чем на 15 нужно писать 1UL << n.
Что собрать после прочтения
Все проекты
Бегущие огни на светодиодах
Огни, которые загораются друг за другом, будто бегут. Arduino зажигает шесть светодиодов по одному; каждый светится короткое мгновение и гаснет, так что свет проходит от начала до конца и начинает…

Светодиодный эффект Knight Rider
Классический бегущий огонь-сканер: светящаяся точка скользит от одного края шести светодиодов к другому и возвращается обратно.

Цифры 0–9 на семисегментном индикаторе
Сам выведи те знакомые цифры, которые видишь в лифтах и электронных часах. На индикаторе из семи маленьких светящихся полосок Arduino каждую секунду показывает цифру от 0 до 9, а затем начинает…

Числа 0–99 на семисегментном индикаторе
Двухразрядный индикатор из маленьких полосок, как на калькуляторе, считает от 0 до 99.

Числа 0–9999 на 4-разрядном семисегментном индикаторе
На четырёхразрядном индикаторе числа несутся от 0 до 9999, а затем снова начинаются с нуля.

Цифровые часы на 4-разрядном семисегментном индикаторе
Светящиеся цифровые часы из четырёх разрядов, почти как на кухонной духовке. Модуль часов DS1302 хранит время, а Arduino каждую секунду читает часы и минуты и показывает их на четырёхразрядном…

Часы и календарь на матрице (MAX7219, DS1307)
Светящееся табло для стола или стены, которое показывает время и дату бегущей строкой.

Пиксельная змейка на матрице 8x8
Собери классическую игру «Змейка» своими руками и сыграй в неё. На цветной светодиодной матрице 8x8 ты джойстиком управляешь зелёной змейкой и ешь красные яблоки; с каждым яблоком змейка растёт…
Другие статьи
Приложение BlueGrays
Собери эту схему шаг за шагом в телефоне
Схема подключения, код и список деталей на одном экране. 500+ проектов на Arduino, ESP32 и Pico готовы к сборке.
Наведи камеру телефона
Наведи камеру на код — откроется магазин приложений на телефоне.
или открыть магазин

