Fundamentos · 12 min de lectura

Sistema binario y hexadecimal: operaciones de bits en Arduino

Sistema binario, conversiones a hexadecimal y decimal, bits y bytes, 0b y 0x en Arduino, &, |, ^, ~, <<, >> con bitRead, y ejemplos con 74HC595 y registros.

El sistema binario usa solo los dígitos 0 y 1 y es la base de toda la electrónica digital. Cada pin, cada registro y cada byte de la memoria de un Arduino es en realidad un número binario hecho de interruptores encendidos o apagados: 1 significa que un pin está en HIGH y 0 que está en LOW. Expresiones que aparecen en el código como 0b10110101, 0xB5 o PORTB |= (1 << 5) pueden asustar, pero en cuanto entiendes el binario y el hexadecimal todas se reducen a unas pocas reglas sencillas.

En esta guía verás primero cómo convertir a mano números decimales, binarios y hexadecimales entre sí, qué son el bit, el nibble y el byte y cómo se guardan los números negativos en memoria. Después aprenderás a escribir números en Arduino con 0b y 0x, a leer y cambiar un solo bit con AND, OR, XOR, NOT y desplazamientos, y a usar las funciones bitRead, bitWrite y bitSet. Por último prepararás bytes para un display de 7 segmentos y un 74HC595, y escribirás directamente en los registros del Uno, el ESP32 y la Pico.

¿Qué es un sistema de numeración? Decimal, binario y hexadecimal

El sistema decimal que usamos a diario tiene 10 dígitos y cada posición vale 10 veces más que la anterior: 181 es 1×100 + 8×10 + 1×1. El sistema binario tiene solo dos dígitos y cada posición vale el doble que la anterior; de derecha a izquierda los valores son 1, 2, 4, 8, 16, 32, 64, 128. El sistema hexadecimal (hex) tiene 16 dígitos: después de 0–9 vienen A=10, B=11, C=12, D=13, E=14, F=15. El hex es tan popular en electrónica porque cada dígito hexadecimal corresponde exactamente a 4 bits; es la forma más práctica de escribir números binarios largos de manera corta y legible.

DecimalBinarioHexDecimalBinarioHex
000000810008
100011910019
200102101010A
300113111011B
401004121100C
501015131101D
601106141110E
701117151111F

Conversiones entre decimal, binario y hex

Para pasar de decimal a binario divides el número por 2 una y otra vez y anotas los restos; leyendo los restos de abajo arriba obtienes el número binario. Para 181: 181/2 = 90 resto 1, 90/2 = 45 resto 0, 45/2 = 22 resto 1, 22/2 = 11 resto 0, 11/2 = 5 resto 1, 5/2 = 2 resto 1, 2/2 = 1 resto 0, 1/2 = 0 resto 1. Leído de abajo arriba queda 10110101. Pasar de binario a decimal es más fácil: sumas los valores de las posiciones que tienen un 1. 10110101 = 128 + 32 + 16 + 4 + 1 = 181.

Valor de posición1286432168421
10110101 (181)10110101
00001100 (12)00001100
11111111 (255)11111111

Para pasar de binario a hex, separa los bits en grupos de cuatro empezando por la derecha y sustituye cada grupo por su dígito hexadecimal de la tabla: 1011 0101 → B 5 → 0xB5. Al revés es igual de fácil: 0x3C → 0011 1100. Para pasar de hex a decimal, multiplica cada dígito por una potencia de 16: 0xB5 = 11×16 + 5 = 181, 0x3FF = 3×256 + 15×16 + 15 = 1023. El último ejemplo te sonará: el límite superior del valor de 10 bits de analogRead en el Uno es 1023, es decir, diez unos. Encontrarás la relación entre lectura analógica y número de bits en el artículo sobre el ADC.

El modo programador de la calculadora de tu ordenador y el Monitor Serie de Arduino son las formas más rápidas de comprobar conversiones. Serial.println(181, BIN) escribe 10110101 y Serial.println(181, HEX) escribe B5. Aun así, hacer la conversión a mano unas cuantas veces te facilita mucho leer tablas de registros y hojas de datos.

Bit, nibble, byte y rangos de valores

Un solo dígito binario se llama bit. 4 bits forman un nibble, es decir, un dígito hexadecimal; 8 bits forman un byte, que se escribe con dos dígitos hex. El bit de más a la derecha de un byte es el menos significativo (LSB, bit 0) y el de más a la izquierda el más significativo (MSB, bit 7). Los números de bit siempre empiezan en 0, por eso los bits de un número de 8 bits se numeran de 0 a 7. Con n bits se pueden escribir 2ⁿ valores distintos: 8 bits son 256, 10 bits 1024 y 16 bits 65536 valores distintos.

TamañoTipo en ArduinoRango sin signoRango con signo
8 bits (1 byte)byte, uint8_t / int8_t0–255-128 a 127
16 bits (2 bytes)int en el Uno, word, uint16_t0–65535-32768 a 32767
32 bits (4 bytes)long, uint32_t; int en ESP32 y Pico0–4.294.967.295-2.147.483.648 a 2.147.483.647

Números negativos: complemento a dos

Los microcontroladores guardan los números negativos en complemento a dos: en un número con signo, si el bit de más a la izquierda es 1, el número es negativo. Para obtener el negativo de un número inviertes todos sus bits y sumas 1. 5 = 00000101; invertido 11111010; sumando 1 queda 11111011 = 0xFB, que es -5. La misma secuencia de bits es un número distinto según cómo la leas: 0xFF es 255 como byte y -1 como int8_t. Por eso es tan importante asignar al tipo correcto los bytes en bruto de un sensor. Cuando una variable supera su límite superior vuelve a empezar: en un byte 255 + 1 = 0 y con int en el Uno 32767 + 1 = -32768; esto se llama desbordamiento (overflow).

Escribir números con 0b, 0x y B en Arduino

En el código de Arduino puedes escribir el mismo número de tres formas y al compilador le da igual: 181 (decimal), 0b10110101 (binario, estándar desde C++14) y 0xB5 (hexadecimal). Arduino también reconoce la forma B10110101 que viene de código antiguo, pero son constantes definidas solo para valores de 8 bits y en código nuevo es mejor 0b. Elegir una u otra depende de la legibilidad: el binario es lo más claro para patrones de LED y ajustes de registros, el hex para direcciones y códigos de color y el decimal para medidas.

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}
En C++, poner un cero delante de un número lo convierte en octal: 010 es ocho, no diez, y 0255 es 173. Si escribes 08 o 09 para alinear números de pin u horas, el compilador da error; si escribes 010, hace lo incorrecto sin avisar. Nunca pongas un cero delante de un número decimal.

Operaciones de bits: &, |, ^, ~, << y >>

Las operaciones de bits comparan uno a uno los bits de la misma posición de dos números. AND (&) da 1 solo si los dos bits son 1; OR (|) da 1 si alguno de los bits es 1; XOR (^) da 1 si los bits son distintos; NOT (~) invierte todos los bits. El desplazamiento a la izquierda (<<) empuja los bits hacia la izquierda y añade ceros por la derecha, multiplicando el número por 2 en cada paso; el desplazamiento a la derecha (>>) los empuja hacia la derecha y divide entre 2 en cada paso. Son la versión en software de las puertas lógicas; puedes ver sus tablas de verdad en el artículo puertas lógicas y en la herramienta de puertas lógicas. La tabla muestra los resultados para a = 0b11001010 (202) y b = 0b10101100 (172):

Operación¿Qué hace?Resultado (binario)HexDecimal
a & bBits que son 1 en los dos100010000x88136
a | bBits que son 1 en al menos uno111011100xEE238
a ^ bBits que son distintos011001100x66102
~a (byte)Se invierten todos los bits001101010x3553
a << 1 (byte)Una posición a la izquierda, el bit de la izquierda se pierde100101000x94148
a >> 2Dos posiciones a la derecha, se pierden los dos bits de la derecha001100100x3250

Fíjate en dos detalles de la tabla. Si el resultado de a << 1 se guarda en un byte, el bit de la izquierda se pierde y queda 148; la misma operación en un int da 404, porque en un int hay sitio para el bit que desborda. Con ~a pasa algo parecido: como byte es 53, pero calculado como int también se invierten los bits superiores y sale -203. En las operaciones de bits siempre debes saber en qué tipo guardas el resultado. Y no confundas & con &&: el primero trabaja bit a bit y el segundo comprueba si dos condiciones son verdaderas.

Máscaras de bits: leer, activar y borrar un solo bit

En proyectos reales, las operaciones de bits casi siempre se usan con una máscara. Una máscara es un número en el que solo valen 1 los bits que te interesan, y normalmente se construye con (1 << n): (1 << 3) = 0b00001000. Con una máscara se hacen cuatro operaciones básicas, y Arduino ofrece una función lista para cada una. El código siguiente guarda el estado de 8 LED en un solo byte en vez de en 8 variables bool y lo refleja en los LED de D2–D9:

ObjetivoCon máscaraFunción de ArduinoEjemplo (n = 3)
Poner el bit a 1x |= (1 << n);bitSet(x, n);00000000 → 00001000
Poner el bit a 0x &= ~(1 << n);bitClear(x, n);11111111 → 11110111
Invertir el bitx ^= (1 << n);bitWrite(x, n, !bitRead(x, n));00001000 → 00000000
Leer (comprobar) el bit(x >> n) & 1bitRead(x, n);00001000 → 1
Escribir un valor en el bitx = (x & ~(1 << n)) | (v << n);bitWrite(x, n, v);v = 1 → 00001000
Valor del bit 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}

Preparar bytes para un display de 7 segmentos

Las ocho partes de un display de 7 segmentos (segmentos a–g y el punto) caben exactamente en un byte. Si asignas el bit 0 al segmento a, el bit 6 al segmento g y el bit 7 al punto decimal (DP), cada dígito se expresa con un solo número. El 2, por ejemplo, se dibuja con los segmentos a, b, d, e y g: 1 + 2 + 8 + 16 + 64 = 91 = 0x5B. En displays de ánodo común un segmento se enciende con LOW, así que inviertes la misma tabla con ~. Para los detalles de conexión de los segmentos consulta el artículo display de 7 segmentos.

DígitoSegmentos encendidosBinario (DP g f e d c b a)Cátodo comúnÁnodo común (~)
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

Enviar el byte a las salidas con un 74HC595

El registro de desplazamiento 74HC595 reparte un byte entre ocho salidas usando solo tres pines, y es el chip donde mejor se ven las operaciones de bits: cada bit del byte que envías enciende o apaga una salida. Cuando shiftOut se usa con MSBFIRST, el bit 7 sale primero y termina en Q7, mientras que el bit 0 llega a Q0. Así que si conectas Q0 al segmento a, Q6 al g y Q7 al DP, la tabla anterior funciona directamente. Para todos los pines del chip y su conexión en cadena, consulta el artículo registro de desplazamiento 74HC595.

ConexiónArduino UnoESP32Raspberry Pi Pico
DS (14), datos serieD11GPIO 23GP19
SH_CP (11), relojD13GPIO 18GP18
ST_CP (12), latchD10GPIO 5GP17
OE (13) / MR (10)GND / 5VGND / 3V3GND / 3V3(OUT)
Q0–Q6 / Q7Segmentos a–g / DP, cada uno con su resistenciaIgualIgual
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}

Escribir directamente en registros: PORTB y DDRB

En el ATmega328P del Uno los pines se agrupan de 8 en 8 en puertos, y cada puerto tiene tres registros: DDRx guarda la dirección del pin (1 = salida), PORTx el nivel de salida y PINx el nivel leído. Los pines D8–D13 están en el puerto B; D13 (el LED integrado) es PB5, el bit 5 de PORTB. pinMode y digitalWrite en realidad cambian estos bits, pero como primero traducen el número de pin a un puerto, tardan unos microsegundos. Escribir directamente en el registro es una sola instrucción máquina y termina en 2 ciclos de reloj a 16 MHz, unos 125 nanosegundos. Además te permite cambiar varios pines del mismo puerto exactamente en el mismo instante.

Pin del UnoPuerto y bitPin del UnoPuerto y bit
D0–D7PD0–PD7 (PORTD)D8–D13PB0–PB5 (PORTB)
A0–A5PC0–PC5 (PORTC)D13 (LED integrado)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}
El código de registros es propio de cada placa: una línea con PORTB que funciona en el Uno controla otros pines en un Mega, no controla nada en un ESP32 o una Pico y ni siquiera compila allí. Además, los bits 0 y 1 de PORTD son los pines del puerto serie; una línea que escribe el puerto entero de golpe, como PORTD = 0xFF, puede estropear Serial. Cambia con una máscara solo los bits que te interesan y usa código de registros solo donde la velocidad importe de verdad.

Controlar pines por registro en el ESP32

En el ESP32 los pines se controlan con registros de 32 bits y, a diferencia de AVR, hay registros separados para activar y borrar: cada bit a 1 que escribes en GPIO_OUT_W1TS_REG (write 1 to set) pone en HIGH el pin correspondiente, cada bit a 1 que escribes en GPIO_OUT_W1TC_REG (write 1 to clear) lo pone en LOW, y los bits a 0 no tocan ningún pin. Como no hace falta leer, modificar y escribir, es seguro con interrupciones y entre los dos núcleos. Estos dos registros solo cubren los GPIO 0–31; para el 32 y siguientes se usan los registros 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}

Unir y separar datos de sensores

Los sensores I2C y SPI suelen enviar las medidas de 16 bits como dos bytes separados: primero el byte alto (MSB) y luego el bajo (LSB). Para unirlos desplazas el byte alto 8 posiciones a la izquierda y haces OR con el byte bajo: int16_t bruto = (msb << 8) | lsb;. Si un acelerómetro envía 0xFC y 0x18, por ejemplo, el resultado es 0xFC18; leído como int16_t, este número es -1000 porque el bit de la izquierda es 1. En sentido contrario, para enviar un número o escribirlo en la EEPROM están highByte(x) y lowByte(x), y word(alto, bajo) para unir dos bytes. La comunicación I2C en sí la tienes en ¿Qué es I2C? y un sensor que trabaja con datos en bruto de dos bytes en el artículo MPU6050.

ExpresiónResultadoExplicación
(0xFC << 8) | 0x180xFC18Une dos bytes en un número de 16 bits
(int16_t)0xFC18-1000Negativo al leerlo con signo porque el bit de la izquierda es 1
highByte(1000)0x031000 = 0x03E8; el byte alto
lowByte(1000)0xE8El byte bajo (232)
word(0x03, 0xE8)1000Vuelve a unir los dos bytes
(estado >> 4) & 0x0FNibble altoSepara los 4 bits superiores de un byte (p. ej. un campo de registro)

Bits en la Raspberry Pi Pico y en MicroPython

En MicroPython valen los mismos operadores y además hay funciones de conversión: bin(), hex() e int(texto, base). Como los enteros de Python crecen sin límite, si quieres que los resultados de ~ y << quepan en un byte tienes que enmascararlos con & 0xFF. El chip RP2040 de la Pico también tiene registros separados de activar, borrar y XOR, como el ESP32, y puedes escribir en ellos directamente con machine.mem32. El código siguiente hace parpadear el LED integrado de la Pico en GP25 con el registro XOR (en la Pico W el LED integrado está conectado al chip Wi-Fi, así que allí usa un LED externo).

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)

Ideas de proyectos con operaciones de bits

  • Contador binario: Haz un contador que cuente de 0 a 255 en 8 LED y mira el sistema binario con tus propios ojos; un botón suma uno y otro resta uno.
  • Efecto coche fantástico: Desplaza un byte con << y >> para que los LED vayan y vuelvan; el montaje paso a paso está en el artículo coche fantástico y LED secuencial.
  • Reloj digital: Muestra la hora en un display de 7 segmentos de cuatro dígitos y haz parpadear cada segundo el punto del segundo dígito con la máscara 0x80.
  • Iconos en matriz LED: Dibuja cada fila de una matriz de 8×8 como un byte y diseña corazones, flechas o letras con 0b. El artículo matriz LED MAX7219 usa este método.
  • Indicadores de ajustes: Guarda ajustes de encendido/apagado como sonido activo, pantalla brillante o alarma puesta en los bits de un solo byte y escríbelos en la EEPROM de una vez.
  • Selección de dirección con DIP switch: Lee un DIP switch de 4 interruptores para obtener una dirección de dispositivo entre 0 y 15.

Errores frecuentes y cómo solucionarlos

Error¿Qué ocurre?Forma correcta
if (x & 0x04 == 0)== se evalúa primero, la expresión queda x & 0 y siempre es falsaif ((x & 0x04) == 0)
Usar 2 ^ 3 como potencia^ es XOR; 2 ^ 3 = 11 << 3 o pow(2, 3)
1 << 15 o 1 << 20 en el UnoEl int de 16 bits desborda: -32768 o 01UL << 20 (unsigned long)
Creer que Serial.println(x, BIN) muestra 8 bitsNo se imprimen los ceros a la izquierda: 12 → 1100Imprime 8 bits en un bucle con bitRead
Poner un 0 delante de un número (010)Se vuelve octal: 010 = 8Quita los ceros a la izquierda de los decimales
Usar el resultado de ~ en un intTambién se invierten los bits superiores: ~0x0F = -16Asigna el resultado a un byte o enmascara con & 0xFF
Escribir && en lugar de &Se comparan dos condiciones, no bitsUn solo & para bits, && para condiciones
Si dudas de una operación de bits, imprime el resultado en tres formatos: Serial.println(x), Serial.println(x, BIN) y Serial.println(x, HEX). Ver el mismo valor en decimal, binario y hexadecimal te muestra al instante si la máscara o el desplazamiento tocaron los bits que esperabas.

Los números binarios y hexadecimales y las operaciones de bits parecen abstractos al principio, pero en electrónica aparecen a diario, desde manejar una fila de LED con un solo byte hasta unir datos de sensores. Aprendidos junto con los fundamentos de programación de Arduino, hacen tu código más corto y más rápido. En la app BlueGrays puedes ver contadores de 7 segmentos, un reloj digital, LED secuenciales, el coche fantástico y proyectos con matriz LED, con esquemas paso a paso y código escrito con estas operaciones de bits.

Preguntas frecuentes

¿Qué es el sistema binario?

El sistema binario usa solo los dígitos 0 y 1 y cada posición vale el doble que la anterior. De derecha a izquierda los valores de posición son 1, 2, 4, 8, 16, 32, 64, 128. Como en los circuitos digitales el 1 representa una tensión alta y el 0 una baja, todos los ordenadores y microcontroladores trabajan con este sistema.

¿Cómo se pasa un número decimal a binario?

Divides el número por 2 hasta llegar a 0 y anotas el resto en cada paso; leyendo los restos de abajo arriba obtienes el número binario. Para 13: 6 resto 1, 3 resto 0, 1 resto 1, 0 resto 1, y el resultado es 1101. Para comprobarlo sumas los valores de los unos: 8 + 4 + 1 = 13.

¿Por qué se usa el sistema hexadecimal?

Cada dígito hexadecimal equivale exactamente a 4 bits, así que es la forma más sencilla de escribir números binarios largos de manera breve y sin errores. Un byte de 8 bits se escribe con dos dígitos hex, por ejemplo B5 en lugar de 10110101. Por eso las direcciones I2C, los códigos de color, los valores de registros y las direcciones de memoria siempre se dan en hex.

¿Qué significan 0b y 0x en Arduino?

Los números que empiezan por 0b se leen en binario y los que empiezan por 0x en hexadecimal; 0b10110101, 0xB5 y 181 son el mismo número. Cuál escribas no importa al compilador, solo a la legibilidad. Arduino también acepta la forma de 8 bits B10110101 del código antiguo.

¿Para qué sirven bitRead y bitWrite?

bitRead(x, n) devuelve el bit número n de x como 0 o 1; bitWrite(x, n, v) pone ese mismo bit al valor v. bitSet y bitClear ponen un bit directamente a 1 o a 0. Estas funciones hacen legibles las máscaras y los desplazamientos; los números de bit empiezan en 0.

¿Qué hacen los operadores << y >> en Arduino?

<< desplaza los bits a la izquierda y multiplica el número por 2 en cada paso; >> los desplaza a la derecha y divide entre 2 en cada paso. 1 << 3 da 8, y así se construyen las máscaras que seleccionan un solo bit. Como en el Uno el int es de 16 bits, para desplazamientos mayores de 15 hay que escribir 1UL << n.

Ver todos los proyectos
Luz secuencial LED
AR-5Intermedio

Luz secuencial LED

Luces que se encienden una tras otra, como si corrieran. El Arduino enciende seis LED de uno en uno; cada uno brilla un instante y se apaga, así que la luz recorre la fila de principio a fin y vuelve…

4.6(87)
218
Efecto coche fantástico con LED
AR-6Intermedio

Efecto coche fantástico con LED

La clásica luz que va y viene: un punto de luz recorre seis LED de un extremo al otro y luego regresa.

4.8(107)
214
Mostrar números del 0 al 9 en un display de 7 segmentos
AR-41Intermedio
Premium

Mostrar números del 0 al 9 en un display de 7 segmentos

Escribe tú mismo esos números tan conocidos de los ascensores y los relojes digitales.

4.5(30)
43
Mostrar números del 0 al 99 en un display de 7 segmentos
AR-42Avanzado
Premium

Mostrar números del 0 al 99 en un display de 7 segmentos

Un indicador de dos cifras hecho de barritas, como el de una calculadora, cuenta de 0 a 99.

4.5(27)
35
Números 0-9999 en un display de 7 segmentos de 4 dígitos
AR-47Intermedio
Premium

Números 0-9999 en un display de 7 segmentos de 4 dígitos

En una pantalla de cuatro dígitos los números corren del 0 al 9999 y luego vuelven a empezar desde cero.

4.4(19)
25
Reloj digital con display de 7 segmentos de 4 dígitos
AR-48Intermedio
Premium

Reloj digital con display de 7 segmentos de 4 dígitos

Un reloj digital luminoso de cuatro cifras, parecido al del horno de la cocina. El módulo de reloj DS1302 guarda la hora y cada segundo el Arduino lee las horas y los minutos y los muestra en el…

4.8(56)
73
Reloj y calendario de matriz de puntos (MAX7219, DS1307)
AR-84Intermedio
Premium

Reloj y calendario de matriz de puntos (MAX7219, DS1307)

Un panel luminoso para tu mesa o tu pared que muestra la hora y la fecha con texto en movimiento.

5.0(37)
59
Serpiente de píxeles Matriz 8x8
AR-88Avanzado
Premium

Serpiente de píxeles Matriz 8x8

Monta con tus propias manos el clásico juego de la serpiente y juega. En una matriz de luces de colores de 8x8 guías una serpiente verde con un joystick y te comes manzanas rojas; con cada manzana la…

4.7(39)
57