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