Основы · 10 мин чтения

Двоичная система счисления: 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 битам; это самый удобный способ коротко и понятно записывать длинные двоичные числа.

ДесятичноеДвоичноеШестнадцатеричноеДесятичноеДвоичноеШестнадцатеричное
000000810008
100011910019
200102101010A
300113111011B
401004121100C
501015131101D
601106141110E
701117151111F

Перевод между десятичной, двоичной и шестнадцатеричной системами

Чтобы перевести число из десятичной системы в двоичную, последовательно дели его на 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.

Вес разряда1286432168421
10110101 (181)10110101
00001100 (12)00001100
11111111 (255)11111111

Чтобы перевести число из двоичной системы в 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, то есть десять единиц. Связь аналоговых измерений с числом битов разобрана в статье об АЦП.

Самые быстрые способы проверить перевод — калькулятор компьютера в режиме программиста и монитор порта Arduino. Serial.println(181, BIN) выводит 10110101, а Serial.println(181, HEX) — B5. Но если несколько раз выполнить перевод вручную, читать таблицы регистров и даташиты станет гораздо легче.

Биты, полубайты, байты и диапазоны значений

Одна двоичная цифра называется битом. 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_t0–255От -128 до 127
16 бит (2 байта)int на Uno, word, uint16_t0–65535От -32 768 до 32 767
32 бита (4 байта)long, uint32_t; int на ESP32 и Pico0–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 — для адресов и кодов цветов, десятичная — для измерений.

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++ ноль перед числом делает его восьмеричным: 010 — это восемь, а не десять, а 0255 — это 173. Если ради выравнивания номеров пинов или значений времени написать 08 или 09, компилятор сообщит об ошибке; с 010 он молча сделает не то, что нужно. Никогда не ставь ведущий ноль в десятичных числах.

Побитовые операции: &, |, ^, ~, << и >>

Побитовые операции последовательно сравнивают биты двух чисел на одинаковых позициях. AND (&), И даёт 1, только если оба бита равны 1; OR (|), ИЛИ даёт 1, если хотя бы один бит равен 1; XOR (^), исключающее ИЛИ даёт 1, если биты различаются; NOT (~), НЕ инвертирует каждый бит. Сдвиг влево (<<) сдвигает биты влево и добавляет справа нули, умножая число на 2 на каждом шаге; сдвиг вправо (>>) сдвигает биты вправо, деля число на 2 на каждом шаге. Это программные аналоги логических элементов; их таблицы истинности есть в статье логические элементы и в утилите логических элементов. Таблица ниже показывает результаты для a = 0b11001010 (202) и b = 0b10101100 (172):

ОперацияЧто делает?Результат (двоичный)ШестнадцатеричныйДесятичный
a & bБиты, равные 1 в обоих числах100010000x88136
a | bБиты, равные 1 хотя бы в одном числе111011100xEE238
a ^ bРазличающиеся биты011001100x66102
~a (byte)Все биты инвертированы001101010x3553
a << 1 (byte)На одну позицию влево, крайний левый бит теряется100101000x94148
a >> 2На две позиции вправо, два крайних правых бита теряются001100100x3250

Обрати внимание на две детали таблицы. Если результат 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)
Установить бит в 1x |= (1 << n);bitSet(x, n);00000000 → 00001000
Сбросить бит в 0x &= ~(1 << n);bitClear(x, n);11111111 → 11110111
Переключить битx ^= (1 << n);bitWrite(x, n, !bitRead(x, n));00001000 → 00000000
Прочитать (проверить) бит(x >> n) & 1bitRead(x, n);00001000 → 1
Записать заданное значение в битx = (x & ~(1 << n)) | (v << n);bitWrite(x, n, v);v = 1 → 00001000
Вес бита n1 << 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-сегментного индикатора

Восемь частей 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)Общий катодОбщий анод (~)
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

Сдвиговый регистр 74HC595 распределяет один байт по восьми выходам, используя всего три пина, и на этой микросхеме побитовые операции особенно наглядны: каждый бит отправленного байта включает или выключает один выход. При использовании shiftOut с MSBFIRST первым отправляется бит 7 и попадает в Q7, а бит 0 — в Q0. Поэтому если подключить Q0 к сегменту a, Q6 к g, а Q7 к DP, таблица выше работает напрямую. Все пины микросхемы и соединение в цепочку разобраны в статье сдвиговый регистр 74HC595.

ПодключениеArduino UnoESP32Raspberry Pi Pico
DS (14), последовательные данныеD11GPIO 23GP19
SH_CP (11), тактовый сигналD13GPIO 18GP18
ST_CP (12), защёлкаD10GPIO 5GP17
OE (13) / MR (10)GND / 5VGND / 3V3GND / 3V3(OUT)
Q0–Q6 / Q7Сегменты a–g / DP, каждый через резисторТо жеТо же
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}

Прямая запись в регистры: 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–D7PD0–PD7 (PORTD)D8–D13PB0–PB5 (PORTB)
A0–A5PC0–PC5 (PORTC)D13 (встроенный светодиод)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}
Код для регистров зависит от платы: строка с PORTB, которая работает на Uno, управляет другими пинами на Mega, а на ESP32 или Pico не управляет ничем и даже не компилируется. Кроме того, биты 0 и 1 PORTD — пины последовательного порта; строка, записывающая весь порт сразу, например PORTD = 0xFF, может нарушить работу Serial. Меняй маской только нужные биты и используй код для регистров лишь там, где скорость действительно важна.

Управление пинами через регистры на ESP32

На ESP32 пинами управляют 32-битные регистры, и, в отличие от AVR, есть отдельные регистры установки и сброса: каждый бит 1, записанный в GPIO_OUT_W1TS_REG (запись 1 для установки), переводит соответствующий пин в HIGH, а каждый бит 1, записанный в GPIO_OUT_W1TC_REG (запись 1 для сброса), — в LOW; нулевые биты не затрагивают пины. Поскольку операция не требует цикла чтение–изменение–запись, она безопасна при прерываниях и работе двух ядер. Эти два регистра охватывают только GPIO 0–31; для 32 и выше используются регистры GPIO_OUT1.

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}

Объединение и разделение данных датчиков

Датчики 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) | 0x180xFC18Объединяет два байта в одно 16-битное число
(int16_t)0xFC18-1000При чтении со знаком число отрицательное, потому что крайний левый бит равен 1
highByte(1000)0x031000 = 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, поэтому там используй внешний светодиод).

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)

Идеи проектов с побитовыми операциями

  • Двоичный счётчик: собери счётчик от 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 = 11 << 3 или pow(2, 3)
1 << 15 или 1 << 20 на Uno16-битный int переполняется: -32768 или 01UL << 20 (unsigned long)
Ожидание, что Serial.println(x, BIN) выводит 8 битВедущие нули не выводятся: 12 → 1100Выводи 8 бит в цикле через bitRead
Ноль перед числом (010)Число становится восьмеричным: 010 = 8Убери ведущие нули из десятичных чисел
Использование результата ~ в intСтаршие биты тоже инвертируются: ~0x0F = -16Присвой результат переменной byte или примени маску & 0xFF
Запись && вместо &Сравниваются два условия, а не битыОдин & для битов, && для условий
Если результат побитовой операции вызывает сомнения, выведи его в трёх формах: Serial.println(x), Serial.println(x, BIN) и Serial.println(x, HEX). Одно и то же значение в десятичной, двоичной и шестнадцатеричной записи сразу покажет, затронули ли маска или сдвиг нужные биты.

Двоичные и шестнадцатеричные числа и побитовые операции поначалу кажутся абстрактными, но в электронике они встречаются каждый день: от управления рядом светодиодов одним байтом до объединения данных датчика. Если изучать их вместе с основами программирования 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.

Все проекты
Бегущие огни на светодиодах
AR-5Средний

Бегущие огни на светодиодах

Огни, которые загораются друг за другом, будто бегут. Arduino зажигает шесть светодиодов по одному; каждый светится короткое мгновение и гаснет, так что свет проходит от начала до конца и начинает…

4.6(87)
218
Светодиодный эффект Knight Rider
AR-6Средний

Светодиодный эффект Knight Rider

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

4.8(107)
214
Цифры 0–9 на семисегментном индикаторе
AR-41Средний
Premium

Цифры 0–9 на семисегментном индикаторе

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

4.5(30)
43
Числа 0–99 на семисегментном индикаторе
AR-42Продвинутый
Premium

Числа 0–99 на семисегментном индикаторе

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

4.5(27)
35
Числа 0–9999 на 4-разрядном семисегментном индикаторе
AR-47Средний
Premium

Числа 0–9999 на 4-разрядном семисегментном индикаторе

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

4.4(19)
25
Цифровые часы на 4-разрядном семисегментном индикаторе
AR-48Средний
Premium

Цифровые часы на 4-разрядном семисегментном индикаторе

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

4.8(56)
73
Часы и календарь на матрице (MAX7219, DS1307)
AR-84Средний
Premium

Часы и календарь на матрице (MAX7219, DS1307)

Светящееся табло для стола или стены, которое показывает время и дату бегущей строкой.

5.0(37)
59
Пиксельная змейка на матрице 8x8
AR-88Продвинутый
Premium

Пиксельная змейка на матрице 8x8

Собери классическую игру «Змейка» своими руками и сыграй в неё. На цветной светодиодной матрице 8x8 ты джойстиком управляешь зелёной змейкой и ешь красные яблоки; с каждым яблоком змейка растёт…

4.7(39)
57