AND bit a bit (&)

AND bit a bit (&)


Los operadores bit a bit realizan sus cálculos a nivel de los bits de las variables. Ellos ayudan a resolver una amplia gama de problemas comunes de programación. Gran parte del material de abajo es parte de un tutorial sobre matemáticas a nivel de bits que se pueden encontrar aquí.

Descripción y sintaxis


A continuación se presentan descripciones y la sintaxis para todos los operadores. Más detalles se pueden encontrar en el tutorial al que se hace referencia.

AND bit a bit (&)


El operador AND en C ++ es un solo signo, &, utilizado entre otras dos expresiones enteras. AND bit a bit opera en cada posición de bit de las expresiones que lo rodean de forma independiente, de acuerdo con esta regla: si los dos bits de entrada están a 1, la salida resultante es 1, de lo contrario la salida es 0. Otra forma de expresar esto es:


0 0 1 1 operando1 

0 1 0 1 operando2 
---------- 
0 0 0 1 (operando1 y operando2) - resultado devuelto


En Arduino, el tipo int es un valor de 16 bits, por lo que usar & entre dos expresiones int provoca 16 operaciones & simultáneas.

En un fragmento de código como:


int a = 92; // En binario: 0000000001011100 

int b = 101; // En binario: 0000000001100101 
int c = a y b; // Resultado: 0000000001000100, o 68 en decimal.


Cada uno de los 16 bits en a y b se procesan utilizando el AND bit a bit, y todos los 16 bits resultantes se almacenan en b, lo que resulta un valor 01000100 en binario, que es 68 en decimal.

Uno de los usos más comunes de la función & es seleccionar un bit en particular (o bits) de un valor entero, a menudo llamado enmascaramiento. Vea más abajo un ejemplo

OR bit a bit (|)


El operador binario OR en C ++ es el símbolo de barra vertical, |. Al igual que el operador &, | opera de manera independiente cada bit en sus dos expresiones enteras que lo rodean, pero lo que hace es diferente. El operador OR bit a bit es 1 si uno o ambos de los bits de entrada es 1, de lo contrario es 0. En otras palabras:


0 0 1 1 operando1 

0 1 0 1 operando2 
---------- 
0 1 1 1 (operando1 | operando2) - resultado devuelto


Aquí hay un ejemplo de la operación OR utilizado en un fragmento de código C ++:


int a = 92;       // En binario: 0000000001011100 

int b = 101;     // En binario: 0000000001100101 
int c = a | b;     // Resultado: 0000000001111101, o 125 en decimal.



Programa de ejemplo para Arduino Uno


Un trabajo común para los operadores AND y OR bit a bit  es lo que los programadores llaman lectura-modificación-escritura en un puerto. En los microcontroladores, un puerto es un número de 8 bits que representa algo acerca de la condición de los pines. Al escribir a un puerto se controlan  todos los pines a la vez.

PORTD es una constante integrada que se refiere a los estados de salida de los pines digitales 0,1,2,3,4,5,6,7. Si hay un 1 en una posición de bit, entonces, el pin está en estado HIGH. (Los pines ya deben estar configurados como salidas con el comando pinMode ().) Así que si escribimos PORTD = B00110001; hemos puesto los pines 0,4 y 5 en estado HIGH. Un pequeño problema aquí es que podemos también cambiar el estado de los pines 0 y 1, que son utilizados por el Arduino para la comunicación serie así que puede haber interferido con la comunicación serie.

Nuestro algoritmo para el programa es:
  • Obtener PORTD y limpiar sólo los bits correspondientes a los pines que deseamos controlar (con AND bit a bit).
  • Combinar el valor PORTD modificado con el nuevo valor para los pasadores bajo control (con OR bit a bit).


int i;   // Variable de contador 

int j; 

void setup () { 
DDRD = DDRD | B11111100;   // establece los bits de dirección de los pines 2 a 7, deja                                                                  //  intactos los pines 0 y 1 (xx | 00 == xx) 
// Igual que pinMode (pin, OUTPUT) para los pines 2 a 7 
Serial.begin (9600); 

void loop () { 
for (i = 0; i <64; i ++) { 

PORTD = PORTD y B00000011;    // borra los bits 2 - 7, deja los pines 0 y 1 intactos (xx y xx                                                                  //11 ==) j = (i << 2); 
// Variable para desplazar a los pines 2 - 7 - y eludir los pines 0 y 1 
PORTD = PORTD | j; 
// Combina la información de los puertos con la nueva información para los pines del LED 
Serial.println (PORTD, BIN); 
// Depuración para mostrar enmascaramiento 
delay (100); 
}


XOR bit a bit (^)


Hay un operador algo inusual en C ++ denominado OR EXCLUSIVO bit a bit, también conocido como XOR bit a bit. (En Inglés esto generalmente se pronuncia "EKS-o".) El operador XOR bit a bit se escribe utilizando el símbolo de intercalación ^. Este operador es muy similar al del operador binario OR |, sólo se evalúa a 0 para una posición de bit dada cuando los dos bits de entrada para esa posición son 1:


    0 0 1 1 operando1

    0 1 0 1 operando2 
    ---------- 
    0 1 1 0 (operando1 ^ operando2) - resultado devuelto


Otra manera de mirar XOR bit a bit es que cada bit del resultado es 1 si los bits de entrada son diferentes, o 0 si son iguales.

Un simple ejemplo de código:


    int x = 12;       // Binario: 1100 

    int y = 10;       // Binario: 1010 
    int z = x ^ y;    // Binaria: 0110, o decimal 6


El operador ^ se utiliza a menudo para conmutar (es decir, cambiar de 0 a 1, o de 1 a 0) algunos de los bits en una expresión entera. En una  operación OR si hay un 1 en el bit de máscara, se invierte el bit; si hay un 0, el bit no se invierte y se mantiene igual. A continuación se muestra un programa hacer parpadear el pin digital 5 .

// Blink_Pin_5


// Demo de O exclusivo 

void setup () { 
DDRD = DDRD | B00100000;    // Configura el pin digital 5 como OUTPUT 
Serial.begin (9600); 

void loop () {
PORTD = PORTD ^ B00100000;    // Invierte el bit 5 (pin digital 5), deja los otros intactos 
delay (100); 
}  


No hay comentarios:

Publicar un comentario