Problema 1 PARASOL

Se desea realizar un circuito de control para el toldo de una terraza de una vivienda. El toldo tiene la función tanto de dar sombra como de proteger del viento y de la

lluvia. Así que es un toldo resistente al viento y a la lluvia, manteniendo la terraza seca en los días de lluvia.

Para el circuito de control tenemos las siguientes entradas:

Señal S: Indica si hay sol Señal L: Indica si llueve Señal V: Indica si hay mucho viento

Señal F: Indica si hace frío en el interior de la casa. Según los valores de estas entradas se bajará o subirá el toldo. Esto se realizará

mediante la señal de salida (Bajar toldo) BT. Si BT='1' indica que el toldo debe estar extendido (bajado) y si BT='0' indica que el toldo debe estar recogido (subido).

El sistema se muestra en la figura.

El circuito que acciona el toldo que debe funcionar según las siguientes

características: Independientemente del resto de señales de entrada, siempre que llueva se

debe de extender el toldo para evitar que se moje la terraza. No se

considerará posible que simultáneamente llueva y haga sol. Si hace viento se debe extender el toldo para evitar que el viento moleste.

Sin embargo, hay una excepción: aun cuando haya viento, si el día está soleado y hace frío en la casa, se recogerá el toldo para que el sol caliente la casa.

Por último, si no hace viento ni llueve, sólo se bajará el toldo en los días de sol y cuando haga calor en el interior, para evitar que se caliente mucho la

casa. Se pide:

a) Realizar la tabla de verdad de la señal que controla el toldo (BT) a partir de las

señales S, L, V y F. (Las señales se deben colocar en este orden para hacer la tabla de izquierda a derecha).

b) Obtener la expresión reducida en suma de productos, y producto de sumas

c) Dibujar el esquema utilizando solo compuertas NAND.

Desarrollo

N° Decimal S L V F BT

0 0 0 0 0 0 1 0 0 0 1 0

2 0 0 1 0 0 3 0 0 1 1 1

4 0 1 0 0 1

5 0 1 0 1 1 6 0 1 1 0 1

7 0 1 1 1 1 8 1 0 0 0 1

9 1 0 0 1 1 10 1 0 1 0 0

11 1 0 1 1 1

12 1 1 0 0 X 13 1 1 0 1 X

14 1 1 1 0 X 15 1 1 1 1 X

Por maxtermino

𝐵𝑇 = (𝑆 + 𝐿 + 𝑉)(𝑆̅ + �̅�)

Por minitermino

𝐵𝑇 = 𝐿 + 𝑆̅𝑉 + 𝑆�̅�

Representando con compuertas NAND

𝐵𝑇 = 𝐿 + 𝑆̅𝑉 + 𝑆�̅� = 𝐿 + 𝑆̅𝑉 + 𝑆�̅�̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅= (�̅�)(𝑆̅𝑉̅̅̅̅ )(𝑆�̅�̅̅̅̅ )̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅

Simulación Proteus- Arduino

Codigo arduino

int pin_S = 13; // Pines Entrada

int pin_L = 12;

int pin_V = 11; int pin_F = 10;

int pin_Y = 6; // Pin Salida Y

void setup() {

pinMode(pin_S, INPUT); // Declara los pines de entrada pinMode(pin_L, INPUT);

pinMode(pin_V, INPUT); pinMode(pin_F, INPUT);

pinMode(pin_Y, OUTPUT); // Declara el pin de salida f }

void loop()

{

boolean pin_SState = digitalRead(pin_S); // Define álgebra booleana para variables entradas y salidas,

boolean pin_LState = digitalRead(pin_L); // Se lee lo que entra en los pines y lo que sale

boolean pin_VState = digitalRead(pin_V); boolean pin_FState = digitalRead(pin_F);

boolean pin_YState;

// Función simplificada f pin_YState = pin_LState | (!pin_SState & pin_VState) | (pin_SState &

!pin_FState);

digitalWrite(pin_Y, pin_YState); // Se muestra en el led lo que sale de la función f

}

Simulación

Problema 2 CÓDIGO EXCESO 3 (XS3)

Se quiere realizar un circuito que reciba un número BCD-XS3 (4 bits) y devuelva '1' si el número recibido es primo, y devuelva '0' si no lo es. Se considerará el número

1 como número primo. El cero no es un número primo. En ningún caso el circuito recibirá números que no estén codificados en BCD-XS3.

Se pide:

a) Realizar la tabla de verdad de la señal de salida. b) Obtener la expresión reducida en suma de productos, y producto de sumas c) Dibujar el diagrama utilizando solo compuertas NOR.

Nota:

El código binario Exceso-3, o 3-exceso (normalmente abreviado como XS3 o X3)

o código Stibitz (por George Stibitz) es un código decimal codificado en

binario autocomplementario y un sistema de numeración. Es una representación

parcial. Exceso-3 fue utilizado en varias computadoras antiguas al igual que

en cajas registradoras y calculadoras electrónicas portátiles en la década del 70.

El código BCD-XS3 (4 bits) se forma al sumarle 3 unidades a cada digito del sistema

decimal.

desarrollo

N° Decimal A B C D BCD- XS3

F

0 0 0 0 0 - X

1 0 0 0 1 - X 2 0 0 1 0 - X

3 0 0 1 1 0 0

4 0 1 0 0 1 1 5 0 1 0 1 2 1

6 0 1 1 0 3 1 7 0 1 1 1 4 0

8 1 0 0 0 5 1 9 1 0 0 1 6 0

10 1 0 1 0 7 1

11 1 0 1 1 8 0 12 1 1 0 0 9 0

13 1 1 0 1 - X 14 1 1 1 0 - X

15 1 1 1 1 - X

Por maxtermino

𝐹 = �̅��̅� + 𝐶�̅� + �̅��̅�

Por minitermino

𝐹 = (𝐴̅̅ ̅ + �̅�)(�̅� + �̅�)(�̅� + �̅�)

Representando con compuertas NOR

𝐹 = (�̅� + �̅�)(�̅� + �̅�)(�̅� + �̅�)

= (�̅� + �̅�)(�̅� + �̅�)(�̅� + �̅�)̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅

= (�̅� + �̅�̅̅ ̅̅ ̅̅ ̅̅ ) + (�̅� + �̅�̅̅ ̅̅ ̅̅ ̅̅ ) + (�̅� + �̅�̅̅ ̅̅ ̅̅ ̅̅ )̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅

Lo que está dentro de la caja:

Simulación Proteus – Arduino

Código Arduino

int pin_A0 = 13; // Pines Entrada

int pin_A1 = 12; int pin_A2 = 11;

int pin_A3 = 10; int pin_F = 6; // Pin Salida F

void setup()

{

pinMode(pin_A0, INPUT); // Declara los pines de entrada pinMode(pin_A1, INPUT);

pinMode(pin_A2, INPUT); pinMode(pin_A3, INPUT);

pinMode(pin_F, OUTPUT); // Declara el pin de salida F }

void loop()

{ boolean pin_A0State = digitalRead(pin_A0); // Define álgebra booleana

para variables entradas y salidas, boolean pin_A1State = digitalRead(pin_A1); // Se lee lo que entra en

los pines y lo que sale boolean pin_A2State = digitalRead(pin_A2);

boolean pin_A3State = digitalRead(pin_A3);

boolean pin_FState;

// Función simplificada F por Maxtérminos pin_FState = (!pin_A2State | !pin_A3State) & (!pin_A0State |

!pin_A1State) & (!pin_A0State | !pin_A3State);

digitalWrite(pin_F, pin_FState); // Se muestra en el led lo que sale de

la función F }

Simulación

Problema 3 ALARMA DE INCENDIOS

Se quiere realizar un circuito para activar la alarma de incendios (A) para la evacuación de un edificio. Para ello se tiene un sensor de gases (G), un sensor de humos (H), y dos

señales procedentes de un termómetro que indican si la temperatura es mayor de 45ºC (T45) y si la temperatura es mayor de 60ºC (T60).

Debido a que a veces los sensores detectan humos y gases que no siempre proceden de incendios (por ejemplo, de los cigarrillos o las cocinas), para evitar falsas alarmas, la señal A se activará cuando se cumplan las siguientes condiciones:

Si la temperatura es mayor de 60ºC siempre se activará la alarma

Si la temperatura está entre 45ºC y 60ºC se activará la alarma sólo si han detectado gases o humos (o ambos).

Si la temperatura es menor de 45ºC se activará la alarma sólo si se detectan gases y humos

Resumiendo, las 4 señales binarias de entrada y la salida:

G: vale '1' si se detecta GAS resultante de la combustión. H: vale '1' si se detecta HUMO. T45: vale '1' si la temperatura es superior a 45ºC T60: vale '1' si la temperatura es superior a 60ºC

La señal de salida A (alarma) se activará a nivel alto Se pide a) Realizar la tabla de verdad de la señal de alarma (A) a partir de las señales de entrada (G, H, T45, T60). (en este orden) y explique su tabla.

b) Obtener la expresión reducida en suma de productos y producto de sumas c) Realice el circuito lógico con solo compuertas NAND.

Desarrollo

a)

N° Decimal G H T45 T60 A

0 0 0 0 0 0

1 0 0 0 1 X 2 0 0 1 0 0

3 0 0 1 1 1 4 0 1 0 0 0

5 0 1 0 1 X 6 0 1 1 0 1

7 0 1 1 1 1

8 1 0 0 0 0 9 1 0 0 1 X

10 1 0 1 0 1 11 1 0 1 1 1

12 1 1 0 0 1 13 1 1 0 1 X

14 1 1 1 0 1

15 1 1 1 1 1

nos indica que estas señales no pueden ser posible ya que no puede haber una temperatura inferior de 45°c y superior a 60°c al mismo tiempo

nos indica que la señal A de la alarma se enciende debido a que detecta humo o gas (o ambos)

con temperatura entre 45°c – 60°c

*

(*)

*

*

*

(*)

*

*

*

(*)

*

*

*

*

*

*

* *

nos indica que se detecta gas, pero no hay temperatura o se detecta una temperatura entre

45°c -60°c, pero no hay la presencia de gas.

El sensor detecta una temperatura superior a 60°c.

El sensor detecta gas y humo con una temperatura inferior a 45°c.

b)

𝐴 = (𝐺 + 𝑇45)(𝐺 + 𝐻 + 𝑇60)(𝐻 + 𝑇45)

(*)

(*)

(1)

𝐴 = 𝑇60 + 𝐺𝑇45 + 𝐺𝐻 + 𝐻𝑇45

(2)

c) con compuertas NAND

para (2)

𝐴 = 𝐺𝑇45 + 𝐻𝑇45 + 𝑇60 + 𝐺𝐻̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅

= (𝐺𝑇45 + 𝐻𝑇45̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ )(𝑇60 + 𝐺𝐻̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅)̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅

= (𝐺𝑇45̅̅ ̅̅ ̅̅ ̅)(𝐻𝑇45̅̅ ̅̅ ̅̅ ̅̅ )(𝑇60̅̅ ̅̅ ̅)(𝐻𝐺̅̅ ̅̅ )̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅

simulación Proteus-arduino

Codigo Arduino

int pinG = 13; int pinH = 12;

int pinT45 = 11; int pinT60 = 10;

int pinOutA = 4; int pinOutA2 = 5;

void setup() {

pinMode(pinG, INPUT); pinMode(pinH, INPUT);

pinMode(pinT45, INPUT); pinMode(pinT60, INPUT);

pinMode(pinOutA, OUTPUT); pinMode(pinOutA2, OUTPUT);

}

void loop() {

boolean bpinG = digitalRead(pinG); boolean bpinH = digitalRead(pinH);

boolean bpinT45 = digitalRead(pinT45); boolean bpinT60 = digitalRead(pinT60);

boolean bpinOutA;

boolean bpinOutA2;

boolean bpinGT45N = !(bpinG & bpinT45);

boolean bpinGHN = !(bpinG & bpinH); boolean bpinHT45N = !(bpinH & bpinT45);

boolean bpinT60N = !bpinT60;

bpinOutA = bpinT60 || (bpinG & bpinT45) || (bpinG & bpinH) || (bpinH & bpinT45);

bpinOutA2 = !( bpinT60N & bpinGT45N & bpinGHN & bpinHT45N );

digitalWrite(pinOutA, bpinOutA); digitalWrite(pinOutA2, bpinOutA2);

}

Simulación

Problema 4: LA NEURONA

El sistema nervioso humano, incluyendo al cerebro, está hecho de billones de células especializadas llamadas neuronas. Cada neurona posee sinapsis (nodos,

puntos de conexión con otras neuronas) que pueden ser de dos tipos: (1) excitatorias e (2) inhibitorias. Cada neurona tiene una sola terminal de salida, (la

cual se denomina axón), y transmite por ella una señal [1] cuando el número de sinapsis excitatorias con entradas [1], excede al número de sinapsis inhibitorias con entrada [1] por al menos el número N (umbral de la neurona).

Determine la función de la salida F(A, B, C, D, E) en el axón de la neurona, dadas las siguientes condiciones:

N=1.

No se presenta nunca el caso en el cual el número de “unos” en las sinapsis de excitación es igual al número de “unos” en la sinapsis de inhibición.

Minimizar F mediante mapas de Karnaugh e implemente el circuito con solo

compuertas NOR.

Desarrollo

N° Decimal

A B C D E F

0 0 0 0 0 0 X

1 0 0 0 0 1 0

2 0 0 0 1 0 0 3 0 0 0 1 1 0

4 0 0 1 0 0 1 5 0 0 1 0 1 X

6 0 0 1 1 0 X 7 0 0 1 1 1 0

8 0 1 0 0 0 1

9 0 1 0 0 1 X 10 0 1 0 1 0 X

11 0 1 0 1 1 0 12 0 1 1 0 0 1

13 0 1 1 0 1 1 14 0 1 1 1 0 1

15 0 1 1 1 1 X

16 1 0 0 0 0 1 17 1 0 0 0 1 X

18 1 0 0 1 0 X 19 1 0 0 1 1 0

20 1 0 1 0 0 1 21 1 0 1 0 1 1

22 1 0 1 1 0 1 23 1 0 1 1 1 X

24 1 1 0 0 0 1

25 1 1 0 0 1 1 26 1 1 0 1 0 1

27 1 1 0 1 1 X 28 1 1 1 0 0 1

29 1 1 1 0 1 1 30 1 1 1 1 0 1

31 1 1 1 1 1 1

𝐹 = (𝐴 + 𝐵 + 𝐶)(𝐵 + �̅� + �̅�)(𝐴 + �̅� + �̅�)

convirtiendo a NOR:

𝐹 = (𝐴 + 𝐵 + 𝐶)(𝐵 + �̅� + �̅�)(𝐴 + �̅� + �̅�)̿̿ ̿̿ ̿̿ ̿̿ ̿̿ ̿̿ ̿̿ ̿̿ ̿̿ ̿̿ ̿̿ ̿̿ ̿̿ ̿̿ ̿̿ ̿̿ ̿̿ ̿̿ ̿̿ ̿̿ ̿̿ ̿̿ ̿̿ ̿

= (𝐴 + 𝐵 + 𝐶̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅) + (𝐵 + �̅� + �̅�̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅) + (𝐴 + �̅� + �̅�̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅)̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅̅ ̅

Lo que esta dentro de la caja:

simulación Proteus – Arduino

Codigo Arduino

int pin_A = 13; // Pines Sinapsis Excitación

int pin_B = 12; int pin_C = 11;

int pin_D = 7; // Pines Sinapsis Inhibición int pin_E = 6;

int pin_F = 2; // Pin Salida F

void setup() {

pinMode(pin_A, INPUT); // Declara los pines de entrada Sinapsis

Excitación pinMode(pin_B, INPUT);

pinMode(pin_C, INPUT); pinMode(pin_D, INPUT); // Declara los pines de entrada Sinapsis

Inhibición pinMode(pin_E, OUTPUT);

pinMode(pin_F, OUTPUT); // Declara el pin de salida F }

void loop()

{ boolean pin_AState = digitalRead(pin_A); // Define álgebra booleana

para variables entradas y salidas, boolean pin_BState = digitalRead(pin_B); // Se lee lo que entra en los

pines y lo que sale

boolean pin_CState = digitalRead(pin_C); boolean pin_DState = digitalRead(pin_D);

boolean pin_EState = digitalRead(pin_E); boolean pin_FState;

// Función simplificada F

pin_FState = (pin_AState | pin_BState | pin_CState) & (pin_BState | !pin_DState | !pin_EState) & (pin_AState | !pin_DState | !pin_EState);

digitalWrite(pin_F, pin_FState); // Se muestra en el led lo que sale de

la función F }