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.
| Decimal | Binario | Hex | Decimal | Binario | Hex |
|---|---|---|---|---|---|
| 0 | 0000 | 0 | 8 | 1000 | 8 |
| 1 | 0001 | 1 | 9 | 1001 | 9 |
| 2 | 0010 | 2 | 10 | 1010 | A |
| 3 | 0011 | 3 | 11 | 1011 | B |
| 4 | 0100 | 4 | 12 | 1100 | C |
| 5 | 0101 | 5 | 13 | 1101 | D |
| 6 | 0110 | 6 | 14 | 1110 | E |
| 7 | 0111 | 7 | 15 | 1111 | F |
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ón | 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 |
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.
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ño | Tipo en Arduino | Rango sin signo | Rango con signo |
|---|---|---|---|
| 8 bits (1 byte) | byte, uint8_t / int8_t | 0–255 | -128 a 127 |
| 16 bits (2 bytes) | int en el Uno, word, uint16_t | 0–65535 | -32768 a 32767 |
| 32 bits (4 bytes) | long, uint32_t; int en ESP32 y Pico | 0–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.
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}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) | Hex | Decimal |
|---|---|---|---|---|
| a & b | Bits que son 1 en los dos | 10001000 | 0x88 | 136 |
| a | b | Bits que son 1 en al menos uno | 11101110 | 0xEE | 238 |
| a ^ b | Bits que son distintos | 01100110 | 0x66 | 102 |
| ~a (byte) | Se invierten todos los bits | 00110101 | 0x35 | 53 |
| a << 1 (byte) | Una posición a la izquierda, el bit de la izquierda se pierde | 10010100 | 0x94 | 148 |
| a >> 2 | Dos posiciones a la derecha, se pierden los dos bits de la derecha | 00110010 | 0x32 | 50 |
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:
| Objetivo | Con máscara | Función de Arduino | Ejemplo (n = 3) |
|---|---|---|---|
| Poner el bit a 1 | x |= (1 << n); | bitSet(x, n); | 00000000 → 00001000 |
| Poner el bit a 0 | x &= ~(1 << n); | bitClear(x, n); | 11111111 → 11110111 |
| Invertir el bit | x ^= (1 << n); | bitWrite(x, n, !bitRead(x, n)); | 00001000 → 00000000 |
| Leer (comprobar) el bit | (x >> n) & 1 | bitRead(x, n); | 00001000 → 1 |
| Escribir un valor en el bit | x = (x & ~(1 << n)) | (v << n); | bitWrite(x, n, v); | v = 1 → 00001000 |
| Valor del bit 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}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ígito | Segmentos encendidos | Binario (DP g f e d c b a) | Cátodo común | Ánodo común (~) |
|---|---|---|---|---|
| 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 |
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ón | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| DS (14), datos serie | D11 | GPIO 23 | GP19 |
| SH_CP (11), reloj | D13 | GPIO 18 | GP18 |
| ST_CP (12), latch | D10 | GPIO 5 | GP17 |
| OE (13) / MR (10) | GND / 5V | GND / 3V3 | GND / 3V3(OUT) |
| Q0–Q6 / Q7 | Segmentos a–g / DP, cada uno con su resistencia | Igual | Igual |
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 Uno | Puerto y bit | Pin del Uno | Puerto y bit |
|---|---|---|---|
| D0–D7 | PD0–PD7 (PORTD) | D8–D13 | PB0–PB5 (PORTB) |
| A0–A5 | PC0–PC5 (PORTC) | D13 (LED integrado) | 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}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.
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ón | Resultado | Explicación |
|---|---|---|
| (0xFC << 8) | 0x18 | 0xFC18 | Une dos bytes en un número de 16 bits |
| (int16_t)0xFC18 | -1000 | Negativo al leerlo con signo porque el bit de la izquierda es 1 |
| highByte(1000) | 0x03 | 1000 = 0x03E8; el byte alto |
| lowByte(1000) | 0xE8 | El byte bajo (232) |
| word(0x03, 0xE8) | 1000 | Vuelve a unir los dos bytes |
| (estado >> 4) & 0x0F | Nibble alto | Separa 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).
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 falsa | if ((x & 0x04) == 0) |
| Usar 2 ^ 3 como potencia | ^ es XOR; 2 ^ 3 = 1 | 1 << 3 o pow(2, 3) |
| 1 << 15 o 1 << 20 en el Uno | El int de 16 bits desborda: -32768 o 0 | 1UL << 20 (unsigned long) |
| Creer que Serial.println(x, BIN) muestra 8 bits | No se imprimen los ceros a la izquierda: 12 → 1100 | Imprime 8 bits en un bucle con bitRead |
| Poner un 0 delante de un número (010) | Se vuelve octal: 010 = 8 | Quita los ceros a la izquierda de los decimales |
| Usar el resultado de ~ en un int | También se invierten los bits superiores: ~0x0F = -16 | Asigna el resultado a un byte o enmascara con & 0xFF |
| Escribir && en lugar de & | Se comparan dos condiciones, no bits | Un solo & para bits, && para condiciones |
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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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…

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.

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.

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.

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.

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…

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.

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…
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

