Lógica combinacional empleando Arduino y álgebra de Boole

En la siguiente tutorial se desea simular un sistema de representación binaria que prende 4 LED’s a partir de unas condiciones de entrada. Después de conocer el problema y los respectivos min-términos, se busca simplificar la función lógica haciendo uso del Álgebra de Boole y del Teorema de Morgan.

 El problema que vamos a resolver consta un circuito digital que tiene como entrada 5 pulsadores (Switchs) P4, P3, P2, P1, P0; que generan señales lógicas y 4 señales de respuesta R3,R2,R1,R0; que indican las siguientes posibilidades:
  • Si el número binario de entrada P4 P3 P2 P1 P0 es mayor que 15 y es múltiplo de 3, debe activarse R3.
  • Si el número binario de entrada es menor o igual a 15 y es múltiplo de 3, debe activarse R2.
  • Si el número binario de entrada es un múltiplo de 5, debe activarse R1.
  • Si el número binario de entrada es un múltiplo de 7 debe activarse R0.
Nos podemos ayudar de a tabla de verdad para determinar los Min-términos de la función o del problema. Esto nos sirve para simplificar la función para prender cada LED representado por R3, R2, R1 y R0.

TABLA DE VERDAD

ENTRADAS
SALIDAS
#
P4
P3
P2
P1
P0
R3
R2
R1
R0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
1
0
0
0
0
2
0
0
0
1
0
0
0
0
0
3
0
0
0
1
1
0
1
0
0
4
0
0
1
0
0
0
0
0
0
5
0
0
1
0
1
0
0
1
0
6
0
0
1
1
0
0
1
0
0
7
0
0
1
1
1
0
0
0
1
8
0
1
0
0
0
0
0
0
0
9
0
1
0
0
1
0
1
0
0
10
0
1
0
1
0
0
0
1
0
11
0
1
0
1
1
0
0
0
0
12
0
1
1
0
0
0
1
0
0
13
0
1
1
0
1
0
0
0
0
14
0
1
1
1
0
0
0
0
1
15
0
1
1
1
1
0
1
1
0
16
1
0
0
0
0
0
0
0
0
17
1
0
0
0
1
0
0
0
0
18
1
0
0
1
0
1
0
0
0
19
1
0
0
1
1
0
0
0
0
20
1
0
1
0
0
0
0
1
0
21
1
0
1
0
1
1
0
0
1
22
1
0
1
1
0
0
0
0
0
23
1
0
1
1
1
0
0
0
0
24
1
1
0
0
0
1
0
0
0
25
1
1
0
0
1
0
0
1
0
26
1
1
0
1
0
0
0
0
0
27
1
1
0
1
1
1
0
0
0
28
1
1
1
0
0
0
0
0
1
39
1
1
1
0
1
0
0
0
0
30
1
1
1
1
0
1
0
1
0
31
1
1
1
1
1
0
0
0
0

Como se puede observar en las salidas, las casillas en '1' muestra con que combinación de de P4, P3, P2, P1 y P0 enciende el LED en esa salida.

Ahora vamos hacer uso del álgebra de Boole para simplificar las funciones. Después se muestra el circuito combinacional, solo con el fin de observar la simplificación final y cómo se puede montar con circuitos integrados.


Funciones

Para Activar R3

R3(P4,P3,P2,P1,P0) =  ∑m(18,21,24,27,30)

FR3(P4,P3,P2,P1,P0) = P4 P3 P2 P1 P0+P4 P3  P2 P1 P0 + P4 P3 P2 P1 P0 +...
...+P4 P3 P2 P1 P0+ P4 P3 P2 P1 P0

FR3(P4,P3,P2,P1,P0) =P4[P3 P2 P1 P0+  P3  P2 P1 P0 + P3 P2 P1 P0 +  P3 P2 P1 P0]

FR3(P4,P3,P2,P1,P0) = P4[P1 P0 ( P3 P2) + P3  P2 (P1 P0) +  P3  P2 P1 P0]

Circuito lógico para R3


Para activar R2

R2(P4,P3,P2,P1,P0) =  ∑m(3,6,9,12,15)

FR2(P4,P3,P2,P1,P0) = P4 P3 P2 P1 P0+P4 P3  P2 P1 P0 + P4 P3 P2 P1 P0 +...
...+P4 P3 P2 P1 P0+ P4 P3 P2 P1 P0

FR2(P4,P3,P2,P1,P0) =P4[P3 P2 P1 P0 + P3  P2 P1 P0 + P3 P2 P1 P0 +P3 P2 P1 P0+...
...+P3 P2 P1 P0]

FR2(P4,P3,P2,P1,P0) = P4[ P3P0 (P2 P1) + P2 P0 (P3 P1) +P3 P2 P1 P0 ]

Circuito lógico para R2


Para activar R1

R1(P4,P3,P2,P1,P0) =  ∑m(5,10,15,20,25,30)

FR1(P4,P3,P2,P1,P0) = P4 P3 P2 P1 P0+P4 P3 P2 P1 P0 + P4 P3 P2 P1 P0 +...
...+P4 P3 P2  P1 P0+ P4 P3 P2 P1 P0 + P4 P3 P2 P1 P0

FR1(P4,P3,P2,P1,P0) = P3 P2 P1 (P4P0) + P3 P2 P1 (P4P0) +...
...+P3 P2  ( P4 P1 P0+P4 P1 P0)

FR1(P4,P3,P2,P1,P0) = P2(P4P0)(P3 P1) +P3 P2  ( P4 P1 P0+P4 P1 P0)

Circuito lógico para R1

Para activar R0

R1(P4,P3,P2,P1,P0) =  ∑m(7,14,21,28)

FR0(P4,P3,P2,P1,P0) = P4 P3 P2 P1 P0+P4 P3 P2 P1 P0 + P4 P3 P2 P1 P0 +...
...+P4 P3 P2  P1 P0

FR0(P4,P3,P2,P1,P0) = P4 P2 P1 (P3P0) +P4 P2 P1  (P3P0)

FR0(P4,P3,P2,P1,P0) = P2 (P3P0)(P4P1)

Circuito lógico para R0
Conociendo las funciones, solo nos queda implementar el código en Arduino. Para lo cual vamos hacer uso de la sintaxis if - else. 

 Te puede interesar (Compuertas lógicas en Arduino)

 Montaje


Código

int P4 = 2, P3 = 3, P2 = 4, P1 = 5, P0 = 6;
int R3 = 10, R2 = 11, R1 = 12, R0 = 13;

void setup() {
  // put your setup code here, to run once:

  /*Entradas*/
  pinMode(P4,INPUT_PULLUP);
  pinMode(P3,INPUT_PULLUP);
  pinMode(P2,INPUT_PULLUP);
  pinMode(P1,INPUT_PULLUP);
  pinMode(P0,INPUT_PULLUP);

  /*Salidas*/
  pinMode(R3,OUTPUT);
  pinMode(R2,OUTPUT);
  pinMode(R1,OUTPUT);
  pinMode(R0,OUTPUT);

  /*Para iniciar led's apagados*/
  digitalWrite(R3, HIGH);
  digitalWrite(R2, HIGH);
  digitalWrite(R1, HIGH);
  digitalWrite(R0, HIGH);
}

void loop() {
  /*
   *Entradas negadas para cambiar configuración del pullup
   *cuando se lee estado de la entrada
   */
  bool a = !digitalRead(P4);
  bool b = !digitalRead(P3);
  bool c = !digitalRead(P2);
  bool d = !digitalRead(P1);
  bool e = !digitalRead(P0);
  
  /*Salida R3*/
  if( a && ( (d&&!e&&!(b^c)) ||  (b&&!c&&!(d^e)) || (!b&&c&&!d&&e) ) ){
      digitalWrite(R3,LOW);
  }else{
      digitalWrite(R3, HIGH);  
  }

  /*Salida R2*/
  if(!a&&( (b&&e&&!(c^d)) || (c&&!e&&(b^d)) || (!b&&!c&&d&&e) )){
      digitalWrite(R2,LOW);
  }else{
      digitalWrite(R2, HIGH);  
  }

  /*Salida R1*/
  if( c&&((a^e)&&(!(b^d))) || b&&!c&& ((!a&&d&&!e)||a&&!d&&e) ){
      digitalWrite(R1,LOW);
  }else{
     digitalWrite(R1,HIGH);   
  }

  /*Salida R0*/
  if( c && (b^e) && (a^d) ){
      digitalWrite(R0,LOW);
  }else{
      digitalWrite(R0, HIGH);
  }
}




DESCARGAR

















































Comentarios















Publicar un comentario






























Entradas más populares de este blog









Compuertas lógicas en Arduino




















Imagen







   Los sistemas digitales son aquellos que funcionan con valores discretos; estos, pueden representarse de diversas formas e inclusive, tener mas de un estado. En lo que nos corresponde, trabajaremos con sistemas binarios, donde solo pueden presentarse dos estados, Alto – bajo, 5V – 0V, True – False. Para trabajar con variables este tipo variables, utilizamos el álgebra de Boole:     En Arduino, disponemos de los siguientes operadores lógicos:     &&   Operador lógico AND  ||        Operador lógico OR  !        Operador lógico NOT  &      Operador de referencia AND  |        Operador de referencia OR   ^       Operador Lógico XOR  ~       Operador negador bit a bit      Te puede interesar ( Comportamiento de los operadores lógicos en Arduino )     En el siguiente proyecto vamos a simular el comportamiento de las compuertas AND, OR, XOR y NOT  empleando el arduino.     Para realizar esta práctica necesitaremos una  protoboard , un  LED  y un dipswitch . Con la ayuda de la se








Seguir leyendo










Manejo display 7 segmentos empleando Arduino




















Imagen







   Nuestro objetivo es implementar un programa que pueda convertir de binario  a sus respectivos caracteres en los sistemas decimal, hexadecimal, octal y  base 5 . Dichos caracteres serán mostrados en un display de 7 segmentos  con ánodo común.     El programa cumplirá los siguientes requisitos        En caso de que este en modo  HEXADECIMAL , se debe implementar la siguiente tabla de caracteres.      Para el modo BCD , cuando los valores binarios son mayores que nueve (9), el display deberá apagarse.   En el modo OCTAL , todo valor binario mayor que siete (7) se debe reemplazar por el pictograma.  En el modo base 5 , si la entrada es mayor que o igual a cinco (5) y menor o igual a diez (10), el display debe permanecer apagado; cuando la entrada es mayor a diez (10), mostrará el pictograma.     Pictograma        Montaje       Las resistencias utilizadas son de  330Ω . La siguiente tabla hace relación a las conexiones de los pines de salida con cada segmento del display.     Segmento Co








Seguir leyendo