XOR bit a bit

AND bit a bit (&)

Los operadores bit a bit realizan sus cálculos a nivel de bits de las variables. Ellos ayudan a resolver una amplia gama de problemas comunes de programación. Gran parte del material de abajo es de un excelente 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 que se hace referencia.

AND bit a bit (&)
El operador AND en C ++ es un solo signo, &, utilizado entre otros 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 son 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 & operando2) - resultado devuelto
En Arduino, el tipo int es un valor de 16 bits, por lo que el uso de & entre dos expresiones int provoca que se produzcan16 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 C, lo que resulta en el valor 01000100 en binario, que es 68 en decimal.
Uno de los usos más comunes de la función AND es seleccionar un bit en particular (o bits) de un valor entero, a menudo llamado enmascaramiento. Vea a continuación 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 en cada bit de sus dos expresiones enteras que lo rodean, pero lo que hace es diferente (por supuesto). El operador OR de dos bits es 1 si uno o ambos de los bits de entrada son 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
Este es un ejemplo de la operación OR utiliza en un fragmento de código C ++:

    int a = 92; // En binario: 0000000001011100
    int b = 101; // En binario: 0000000001100101
    int c = a | segundo; // 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 controla todas 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 deben estar configurados como salidas con el comando pinMode () ) Así que si escribimos PORTD = B00110001; hemos llevado los pines 0,4 y 5 a nivel HIGH. Un pequeño problema aquí es que también podemos cambiar el estado de los pines 0 y 1, que son utilizados por el Arduino para comunicaciones 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 pines bajo control (con OR bit a bit).

int j;

void setup(){
  DDRD = DDRD | B11111100;   // selecciona la dirección de los bit 2 a 7, deja 0 y 1 sin tocar (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 & B00000011;    // borra los bits 2 - 7, ldeja los pines 0 y 1 sin tocar (xx & 11 == xx) 
  j = (i << 2);     // desplaza los pines 2 - 7 de la variable - para eludir los pines 0 y 1 
  PORTD = PORTD | j;    // combina la información de los puertos con la nueva información para los pines LED
  Serial.println(PORTD, BIN); // debug to show masking
  delay(100);
}
}

XOR bit a bit (^)

Hay un operador algo inusual en C ++ denominadoOR 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 a la 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.

Aquí un sencillo ejemplo de código:

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

El operador ^ se utiliza a menudo para cambiar (es decir, cambio 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, el bit se invierte; si hay un 0, el bit no se invierte y se mantiene igual. A continuación se muestra un programa para producir un parpadeo en pin digital 5.

// Blink_Pin_5
// Demo de OR Exclusivo

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

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

No hay comentarios:

Publicar un comentario