Aprender

Operadores bit a bit y bitRead de Arduino, en un dígito de siete segmentos

Principiante

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Arduino Uno: un dígito de siete segmentos encendido con los bits de un byteen vivo0.000 s 0.00x
Haz clic para abrirlo en el editor
Cada dígito es un byte; bitRead() extrae el bit de cada segmento.

Los operadores bit a bit trabajan sobre los bits individuales de un número. & (and) conserva los bits activados en ambos números, | (or) los bits activados en cualquiera de los dos, ^ (xor) los bits activados en uno pero no en ambos, ~ (not) invierte cada bit, y << y >> desplazan los bits a la izquierda o a la derecha. Arduino agrega bitRead(), bitWrite(), bitSet() y bitClear() para trabajar de un bit a la vez.

El circuito de arriba es un dígito de siete segmentos conectado directo a un Uno, contando de 0 a 9 una vez por segundo. Cada dígito es un byte con el segmento a en el bit 0, y bitRead(DIGITS[n], s) decide si el segmento s se enciende. Presiona Ejecutar y observa cómo cuenta; el monitor serie imprime cada número según lo va mostrando.

Abajo se explica cómo funciona ese byte, los seis operadores con lo que imprimió cada uno, activar y probar un solo bit, los desplazamientos que se quedan sin espacio, & contra &&, y unir dos bytes en un solo número.

Un byte por dígito

Aquí están la tabla y la función del sketch de arriba. 0x06 es 0b00000110 en binario: los bits 1 y 2 están activados, que son los segmentos b y c, los dos de la derecha, y eso es un 1. 0x3F activa los seis bits de a a f, todo menos la barra del medio, que es un 0. show() recorre los siete bits y escribe cada uno en el pin de su segmento.

Diez bytes guardan los diez dígitos. Diez arreglos de siete HIGH y LOW guardarían lo mismo en catorce veces más espacio.

firmware/uno/examples/sfseg (el dígito que se ejecuta arriba)
const byte DIGITS[10] = {0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F};
const int SEGMENT_PINS[7] = {7, 6, 5, 11, 10, 8, 9};  // a to g
const int DOT_PIN = 4;

void show(int n) {
  for (int s = 0; s < 7; s++) digitalWrite(SEGMENT_PINS[s], bitRead(DIGITS[n], s));
}

Los seis operadores

Con a en 1100 y b en 1010 en binario, el sketch de abajo imprimió 1000 para a & b, 1110 para a | b, 110 para a ^ b, 11000 para a << 1 y 11 para a >> 2. Desplazar a la izquierda por uno duplica un número y desplazar a la derecha por uno lo divide a la mitad, descartando el residuo.

Los números se pueden escribir de tres maneras. 0b1100 es binario, 0x0C es hexadecimal y 12 es decimal, y los tres son el mismo número para el compilador. El binario es el más fácil de leer cuando cada bit significa una cosa, como un segmento o un interruptor, y el hexadecimal es más corto para bytes completos: cada dígito hexadecimal son exactamente cuatro bits.

~a imprimió -13, no 11110011. El ~ operó sobre un int, porque C++ convierte un byte en int antes de hacer aritmética con él, así que los dieciséis bits se invirtieron y el de arriba lo volvió negativo. Convierte la respuesta de vuelta, (byte)~a, e imprimió 11110011.

Cada operador sobre dos bytes
void setup() {
  Serial.begin(9600);
  byte a = 0b1100;
  byte b = 0b1010;
  Serial.println(a & b, BIN);
  Serial.println(a | b, BIN);
  Serial.println(a ^ b, BIN);
  Serial.println(a << 1, BIN);
  Serial.println(a >> 2, BIN);
  Serial.println(~a);
  Serial.println((byte)~a, BIN);
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Activar, borrar, invertir y probar un bit

1 << n es un número con solo el bit n activado, llamado máscara. flags |= (1 << 3) activa el bit 3 y deja el resto igual, flags &= ~(1 << 3) lo borra, flags ^= (1 << 0) invierte el bit 0, y if (flags & (1 << 0)) lo prueba. El sketch de abajo imprimió 1000, 1001 y 1, y luego "el bit 0 está activado".

Los nombres propios de Arduino dicen lo mismo con palabras. bitSet(flags, 3), bitClear(flags, 0), bitWrite(flags, 7, 1) y bitRead(flags, 3) trabajan sobre un bit, y bit(5) es 32, el valor del bit 5 por sí solo. Usa el que se lea mejor; generan el mismo código.

Máscaras
void setup() {
  Serial.begin(9600);
  byte flags = 0b00000000;
  flags |= (1 << 3);
  Serial.println(flags, BIN);
  flags ^= (1 << 0);
  Serial.println(flags, BIN);
  flags &= ~(1 << 3);
  Serial.println(flags, BIN);
  if (flags & (1 << 0)) {
    Serial.println("bit 0 is set");
  }
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Desplazamientos que se quedan sin espacio

Un número común como 1 es un int, y un int en un Uno tiene 16 bits. 1 << 15 imprimió -32768, porque el bit 15 es el bit de signo. 1 << 16 y long big = 1 << 20 desplazan más allá del límite: clang advirtió shift count >= width of type, e imprimieron 256 y 16777221, ninguno correcto. Guardar la respuesta en un long no ayuda, porque el desplazamiento ya salió mal.

Haz que el 1 sea un unsigned long primero: 1UL << 16 imprimió 65536. Haz lo mismo siempre que un desplazamiento pueda pasar del bit 14, para un valor de registro de 32 bits o una máscara para una pantalla de 24 pines.

& no es &&, y los paréntesis que importan

&& pregunta si ambos lados son verdaderos; & compara bits. Con x en 4, if (x & 2) fue falso, porque 100 y 010 no comparten ningún bit, y if (x && 2) fue verdadero, porque ninguno es cero. Clang advirtió en el segundo: use of logical '&&' with constant operand. Lo mismo aplica para | y ||.

== se evalúa antes que &, así que if (flags & 0b1000 == 0b1000) prueba flags & 1. Con flags en 1000 imprimió "no activado". Clang advirtió & has lower precedence than ==; == will be evaluated first. Pon paréntesis alrededor de la máscara: if ((flags & 0b1000) == 0b1000).

Dos bytes en un número, y de vuelta

Los sensores en I2C y SPI a menudo envían una lectura como un byte alto y un byte bajo. (high << 8) | low los vuelve a unir: 0x03 y 0xE8 formaron 1000. value >> 8 saca de nuevo el byte alto y value & 0xFF el bajo, que imprimieron 3 y 232.

Unir y separar
void setup() {
  Serial.begin(9600);
  byte high = 0x03;
  byte low = 0xE8;
  int value = (high << 8) | low;
  Serial.println(value);
  Serial.println(value >> 8);
  Serial.println(value & 0xFF);
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Abre este circuito en el editor. Arduino Uno: un dígito de siete segmentos encendido con los bits de un byte, cableado como se ejecuta en la parte superior de esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Abrir el circuito

Preguntas

¿Qué hace & en Arduino?

Entre dos números es un and bit a bit: cada bit del resultado es 1 solo donde ambos números tienen un 1. Antes de una variable significa "la dirección de", que es otra cosa.

¿Cuál es la diferencia entre & y && en Arduino?

&& es un and lógico, verdadero cuando ambos lados son distintos de cero. & compara los números bit por bit. 4 & 2 es 0, lo cual es falso; 4 && 2 es verdadero.

¿Cómo leo un solo bit de un byte en Arduino?

bitRead(value, n) da 0 o 1 para el bit n, contando desde 0 a la derecha. (value >> n) & 1 es lo mismo escrito con operadores.

¿Qué significa 1 << n?

Un número con solo el bit n activado: 1 << 3 es 8. Es la máscara para activar, borrar o probar el bit n. Escribe 1UL << n cuando n pueda ser 15 o más.

Fuentes

De dónde vienen los datos de esta página

Ármalo en la vida real

Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.