/*
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
Contador binario de cuatro bits
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
---------------------------------------------
Se estudiará el concepto de "Máscara de bits"
---------------------------------------------
*/
//Inicio del código
//Define los pines "bits" a utilizar
const int LED[] = {19, 21, 22, 23};
//Declara un contador
int valor = 0;
void setup() {
// Inicializa la comunicación serial
Serial.begin(115200);
//Define los pines como salidas
for (int i = 0; i < 4; i++) {
pinMode(LED[i], OUTPUT);
}
}
void loop() {
// Agrega una pequeña pausa para dar tiempo a la simulación
delay(10);
//Inicia el contador
valor++;
if (valor == 16) {
valor = 0; // Inicializa el contador en cero cuando éste llega quince
}
//Llama a la función "binario"
binario(valor);
//Establece un delay de 1 seg.
delay(1000);
}
//Crea la función "binario"
void binario(int x) {
// Establece el rango de operación
if (x >= 0 && x <= 15) {
for (int i = 0; i < 4; i++) {
// Utiliza una máscara para obtener el valor del bit en la posición 'i'
digitalWrite(LED[i], (x >> i) & 1);
}
}
}
//Fin del código.
/*
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
La línea `digitalWrite(LED[i], (x >> i) & 1);` es una expresión en
C o C++ que se utiliza para controlar el estado de un LED en
función del valor de un bit específico en la representación
binaria del número `x`. Vamos a analizarla en detalle:
1. `(x >> i)` - Esta parte de la expresión realiza un desplazamiento
hacia la derecha de los bits en `x` por `i` posiciones.
El operador `>>` se utiliza para desplazar los bits hacia la derecha.
Cada vez que se ejecuta el bucle, `i` toma valores de 0 a 3, lo que
significa que estamos desplazando el número `x` por 0, 1, 2 y 3 posiciones.
Esto coloca el bit que nos interesa (0, 1, 2 o 3) en la posición menos
significativa.
`(x >> i)` es una operación de desplazamiento hacia la derecha en bits.
Lo que significa es que estamos tomando un número `x` (representado en binario)
y moviendo sus bits hacia la derecha por `i` posiciones, donde `i` es una
variable que varía de 0 a 3 en un bucle.
Ejemplo 1:
Con `x` inicialmente igual a `10110110` (en binario). Vamos a mostrar cómo
cambia `x` en cada iteración del bucle cuando `i` toma valores de 0 a 3:
1. Cuando `i` es 0, no se realiza ningún desplazamiento. `x` se mantiene
igual: `10110110`.
2. Cuando `i` es 1, se desplaza un bit hacia la derecha: `01011011`.
3. Cuando `i` es 2, se desplaza dos bits hacia la derecha: `00101101`.
4. Cuando `i` es 3, se desplaza tres bits hacia la derecha: `00010110`.
Cada vez que `i` aumenta en el bucle, el bit que nos interesa (0, 1, 2 o 3)
se coloca en la posición menos significativa (el extremo derecho). Esto es útil
en muchas situaciones, como cuando necesitas aislar o manipular bits específicos
en un número, como se describe en los ejemplos anteriores.
En resumen, `(x >> i)` se refiere a la operación de desplazamiento hacia la
derecha de los bits en `x` por `i` posiciones, y esto se logra utilizando el
operador `>>`.
Ejemplo 2:
Utilizando números de cuatro bits para ilustrar la operación de
desplazamiento hacia la derecha `(x >> i)` con valores de `i` variando de 0 a 3.
Supongamos que tenemos un número de 4 bits, `x = 1101` (en binario).
A continuación, veremos cómo cambia `x` en cada iteración del bucle cuando `i`
varía de 0 a 3:
1. Cuando `i` es 0, no se realiza ningún desplazamiento. `x` se mantiene igual: `1101`.
2. Cuando `i` es 1, se desplaza un bit hacia la derecha: `0110`.
3. Cuando `i` es 2, se desplazan dos bits hacia la derecha: `0011`.
4. Cuando `i` es 3, se desplazan tres bits hacia la derecha: `0001`.
Cada vez que `i` aumenta en el bucle, el bit que nos interesa se coloca en la
posición menos significativa (el extremo derecho), y los bits a la izquierda se
desplazan hacia la derecha. Esto muestra cómo la operación `(x >> i)` cambia el
valor de `x` según el valor de `i` y cómo el bit de interés se mueve hacia la
posición menos significativa en cada iteración.
2. `& 1` - Después del desplazamiento hacia la derecha, se aplica una
máscara de bits. La máscara utilizada es `1`. La operación `&`(AND) a nivel
de bits entre el resultado del desplazamiento y `1` se asegura de que
solo el bit menos significativo (el bit en la posición 0) se conserve y
los demás se vuelvan 0. Esto se hace para aislar el valor de un solo bit
en la representación binaria de `x`.
3. `digitalWrite(LED[i], ...)` - Finalmente, el valor resultante después
del desplazamiento y la máscara se utiliza como argumento para la función
`digitalWrite`. Esta función controla el estado de un LED específico
(indicado por `LED[i]`) en función del valor del bit aislado.
Si el bit es `1`, el LED se encenderá; si el bit es `0`, el LED se apagará.
En resumen, esta línea de código se encarga de tomar el valor del bit en
la posición `i` de la representación binaria de `x`, aislarlo y luego utilizarlo
para controlar el estado de un LED específico. Esto permite mostrar la
representación binaria de `x` en una serie de LEDs, donde cada LED representa
un bit en la secuencia binaria.
-------------------------------------------------------------------------------------
INFORMACIÓN SOBRE LA MÁSCARA DE BITS
¿Qué es una máscara de bits?
Una máscara de bits es un valor que se utiliza en operaciones a nivel de
bits para seleccionar, modificar o aislar ciertos bits en una secuencia de
bits más grande. En esencia, una máscara de bits es una serie de bits que
se utiliza como patrón para aplicar ciertas operaciones a otros bits.
Las operaciones comunes que se realizan con máscaras de bits incluyen:
1. Aislamiento de bits: Una máscara de bits se utiliza para aislar uno o
más bits específicos de un valor mayor. Esto se logra mediante una operación
de "y" a nivel de bits (AND) entre la máscara y el valor original. Los bits
en la máscara que están establecidos en 1 permitirán que los bits correspon-
dientes en el valor original pasen sin cambios, mientras que los bits en la
máscara que están en 0 harán que los bits correspondientes en el valor original
se vuelvan 0.
2. Modificación de bits: Puedes usar una máscara de bits para cambiar ciertos
bits en un valor sin afectar los demás. Esto se logra combinando el valor
original con la máscara mediante una operación de "o" a nivel de bits (OR).
Los bits en la máscara que están en 1 modificarán los bits correspondientes
en el valor original, mientras que los bits en la máscara que están en 0 no
tendrán ningún efecto.
3. Borrado de bits: Una máscara de bits puede utilizarse para borrar ciertos
bits en un valor estableciéndolos en 0, mientras que los otros bits permanecen
sin cambios. Esto se logra mediante una operación de "y" a nivel de bits (AND)
entre la máscara complementaria (todos los bits en 1, excepto los que se
quieren borrar) y el valor original.
4. Pruebas de bits: Puedes usar una máscara de bits para verificar si ciertos
bits en un valor tienen un valor específico. Esto se hace mediante una operación
de "y" a nivel de bits (AND) entre la máscara y el valor original, seguida de
una comparación del resultado con el valor deseado.
En resumen, una máscara de bits es una herramienta fundamental en la manipulación
de valores binarios para realizar operaciones precisas en bits individuales o
grupos de bits en una secuencia de bits más grande.
------------------------------------------------------------------------------------
Una máscara de bits, a menudo conocida simplemente como "máscara", es una
técnica utilizada en programación y computación para realizar operaciones
de bits en datos binarios. Una máscara de bits es una secuencia de bits
que se utiliza para seleccionar o modificar ciertas partes específicas de
otro conjunto de bits. Se utiliza comúnmente en combinación con operaciones
de bits como AND, OR y XOR para realizar tareas específicas, como la manipulación
de bits individuales o la extracción de información de un conjunto de bits.
Para entender mejor cómo funciona una máscara de bits, aquí hay algunas
operaciones comunes que se pueden realizar con ella:
1. Máscara de bits para extracción:
Puedes usar una máscara para extraer ciertos bits específicos de un
número o conjunto de datos. Por ejemplo, si tienes un número binario
y deseas extraer los últimos 4 bits, puedes usar una máscara de bits
como "00001111" (en binario) y realizar una operación AND para aislar
esos 4 bits.
2. Máscara de bits para establecer valores:
Puedes usar una máscara de bits para establecer ciertos bits en un valor
específico. Por ejemplo, si deseas establecer los primeros 3 bits de un
número en 1, puedes usar una máscara como "00000111" y realizar una
operación OR para lograrlo.
3. Máscara de bits para limpiar bits:
Puedes usar una máscara de bits para poner en cero (limpiar) ciertos
bits en un número mientras mantienes los demás sin cambios. Por ejemplo,
si deseas borrar los bits 2 y 3 de un número, puedes usar una máscara como
"11111011" y realizar una operación AND para lograrlo.
4. Máscara de bits para realizar operaciones lógicas:
Las máscaras de bits también se utilizan en combinación con operadores
lógicos como AND, OR y XOR para realizar operaciones específicas en bits
individuales o grupos de bits.
En resumen, una máscara de bits es una herramienta poderosa para
realizar operaciones de bits precisas en datos binarios. Se compone de
una secuencia de bits que se utilizan como patrón para seleccionar,
modificar o realizar operaciones en bits específicos dentro de un conjunto
de datos binarios más grande. Esto es útil en diversas aplicaciones de
programación, como manipulación de hardware, compresión de datos,
encriptación y muchas otras áreas donde se necesita un control preciso sobre
los bits.
**Ejemplo 1: Extracción de bits**
Supongamos que tienes un número binario de 8 bits, `11011010`, y
deseas extraer los últimos 4 bits de este número. Para hacerlo,
utilizarás una máscara de bits que tenga 1s en las posiciones de
los bits que deseas extraer y 0s en las posiciones que deseas descartar.
La máscara en este caso sería `00001111` (15 en decimal). Ahora, realizarás
una operación lógica AND entre el número original y la máscara:
```
Número original: 11011010
Máscara: 00001111
Resultado: 00001010
```
El resultado es `00001010`, que son los últimos 4 bits del número original.
**Ejemplo 2: Establecimiento de bits**
Supongamos que tienes un número binario de 8 bits, `10100110`, y deseas
establecer los primeros 3 bits en 1. Para hacerlo, utilizarás una máscara
de bits que tenga 1s en las posiciones de los bits que deseas establecer
en 1 y 0s en las posiciones que deseas mantener sin cambios. La máscara en
este caso sería `00000111` (7 en decimal). Ahora, realizarás una operación
lógica OR entre el número original y la máscara:
```
Número original: 10100110
Máscara: 00000111
Resultado: 10100111
```
El resultado es `10100111`, donde los primeros 3 bits se han establecido en 1.
**Ejemplo 3: Limpieza de bits**
Supongamos que tienes un número binario de 8 bits, `11011001`, y deseas poner
en 0 el cuarto bit desde la derecha (el bit de la posición 3). Para hacerlo,
utilizarás una máscara de bits que tenga 0 en la posición del bit que deseas
poner en 0 y 1s en las demás posiciones. La máscara en este caso sería `11110111`
(247 en decimal). Ahora, realizarás una operación lógica AND entre el número
original y la máscara:
```
Número original: 11011001
Máscara: 11110111
Resultado: 11010001
```
El resultado es `11010001`, donde el cuarto bit desde la derecha se ha puesto en 0.
**Ejemplo 4: Operación lógica con máscara**
Supongamos que tienes dos números binarios de 8 bits, `10101010` y `11001100`, y
deseas realizar una operación lógica AND bit a bit solo en los primeros 4 bits
de cada número. Utilizarás una máscara de bits que tenga 1s en las posiciones de
los primeros 4 bits y 0s en las posiciones restantes. La máscara en este caso
sería `11110000` (240 en decimal). Ahora, realizarás una operación lógica AND
entre ambos números y la máscara:
```
Número 1: 10101010
Número 2: 11001100
Máscara: 11110000
Resultado: 10001000
```
El resultado es `10001000`, donde solo se ha realizado la operación AND en los
primeros 4 bits de ambos números.
Estos ejemplos deberían ayudarte a comprender mejor cómo se utilizan las máscaras
de bits para extraer, establecer, limpiar y realizar operaciones lógicas en bits
específicos dentro de datos binarios.
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
*/