UNIDAD 5

ASCII

ASCII Hex Símbolo 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 A B C D E F NUL SOH STX ETX EOT ENQ ACK BEL BS TAB LF VT FF CR SO SI	ASCII Hex Símbolo 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F DLE DC1 DC2 DC3 DC4 NAK SYN ETB CAN EM SUB ESC FS GS RS US	ASCII Hex Símbolo 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F (space) ! " # $ % & ' ( ) * + , - . /	ASCII Hex Símbolo 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
ASCII Hex Símbolo 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F @ A B C D E F G H I J K L M N O	ASCII Hex Símbolo 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F P Q R S T U V W X Y Z [ \ ] ^ _	ASCII Hex Símbolo 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 60 61 62 63 64 65 66 67 68 69 6A 6B 6C 6D 6E 6F ` a b c d e f g h i j k l m n o	ASCII Hex Símbolo 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 70 71 72 73 74 75 76 77 78 79 7A 7B 7C 7D 7E 7F p q r s t u v w x y z { | } ~ 

Mapa de Karnaugh

Los Mapas de Karnaugh son una herramienta muy utilizada para la simplificación de circuitos lógicos. Cuando se tiene una función lógica con su tabla de verdad y se desea implementar esa función de la manera más económica posible se utiliza este método.

Ejemplo: Se tiene la siguiente tabla de verdad para tres variables.

Se desarrolla la función lógica basada en ella. (Primera forma canónica). Ver que en la fórmula se incluyen solamente las variables (A, B, C) cuando F cuando es igual a "1".

Si A en la tabla de verdad es "0" se pone A, si B = "1" se pone B, Si C = "0" se pone C, etc.

 

F = A B C + A B C + A BC + A B C + A B C + A B C

Una vez obtenida la función lógica, se implementa el mapa de Karnaugh.

Este mapa tiene 8 casillas que corresponden a 2n, donde n = 3 (número de variables (A, B, C)). Ver el diagrama arriba a la derecha.

La primera fila corresponde a A = 0

La segunda fila corresponde a A = 1

La primera columna corresponde a BC = 00 (B=0 y C=0)

La segunda columna corresponde a BC = 01 (B=0 y C=1)

La tercera columna corresponde a BC = 11 (B=1 y C=1)

La cuarta columna corresponde a BC = 10 (B=1 y C=0)

En el mapa de Karnaugh se han puesto "1" en las casillas que corresponden a los valores de F = "1" en la tabla de verdad. Tomar en cuenta la numeración de las filas de la tabla de verdad y la numeración de las casillas en el mapa de Karnaugh.

Para proceder con la simplificación, se crean grupos de "1"s que tengan 1, 2, 4, 8, 16, etc. (sólo potencias de 2). Los "1"s deben estar adyacentes (no en diagonal) y mientras más "1"s tenga el grupo, mejor.

La función mejor simplificada es aquella que tiene el menor número de grupos con el mayor número de "1"s en cada grupo

Se ve del gráfico que hay dos grupos cada uno de cuatro "1"s, (se permite compartir casillas entre los grupos).

La nueva expresión de la función booleana simplificada se deduce del mapa de Karnaugh.

- Para el primer grupo (rojo): la simplificación da B (los "1"s de la tercera y cuarta columna) corresponden a B sin negar)

- Para el segundo grupo (azul): la simplificación da A (los "1"s están en la fila inferior que corresponde a A sin negar)

Entonces el resultado es F = B + A o F = A + B

Ejemplo:

Una tabla de verdad como la de la derecha da la siguiente función booleana:

F = ABC + AB C + A B C + A B C

Se ve claramente que la función es un reflejo del contenido de la tabla de verdad cuando F = "1"

Con esta ecuación se crea el mapa de Karnaugh y se escogen los grupos. Se lograron hacer 3 grupos de dos "1"s cada uno.

Se puede ver que no es posible hacer grupos de 3, porque 3 no es potencia de 2. Se observa que hay una casilla que es compartida por los tres grupos.

La función simplificada es: F = AB + AC + BC. Grupo en azul: AB, grupo marrón: AC, grupo verde: BC

MINITERMINOS Y MAXITERMINOS

Una variable binaria podrá  aparecer  en su forma normal o  en su forma complementaria.

Considere  ahora  dos variables  binarias  y que se combina con una operación  AND.

Puesto que cada  variable  podrá  aparecer  en cualquier  de sus formas , hay    cuatro   combinaciones  posibles  x y, xy, xy y xy  cada  uno  de esto   cuatro miniterminos  AND  es un es una mini termino, o producto  estándar. De manera  similar , podemos  combinar n variable  para formar 2η- 1 bajo las  n variables.  Cada  miniternino  se obtiene  de un termino AND  de las  n variables , poniendo a un apostrofo a  cada  variable  si el  bit  correspondiente  del numero  binario  es un  0  y sin apostrofo   si es un 1. en la tabla  también  se muestra  un símbolo  para  cada  minitermino, el cual  tiene  la forma  m , donde j denota  el equivalente decimal  del numero  binario  del minitermino designado.

 Asimismo , n  variable  que forman un término  OR  donde  cada  variable  puede  tener  apostrofo o no  dan  pie a 2 n  posibles  combinaciones, llamadas  maxiterminos  o sumas estándar. En  la tabla 2-3  se presentan  los  ocho maxiterminos  de tres variables, junto  con su designación  simbólica. Podemos   obtener  de manera  similar  cualesquier 2n maxiterminos para n variables.

Se puede  expresar  algebraicamente  una  función  booleana   a partir  de una tabla  de verdad  dada  formando un minitermino  para  cada combinaciones de las  variables  que  producen un 1 en  la funció  y formando  después  el OR  de todos  estos términos.

 Dijimos antes que para n  variables   binarias , podemos   obtener 2n  miniterminos  distintos  y que  es posible  expresar cualquier  función  booleana  como  una suma  de miniterminos. Los  miniterminos  cuya  suma define  a la función  booleana  son los que producen  los  unos de la  función en  una tabla  de verdad.  Puesto que la función puede dar  1 o 0con cada   minitermino.

Expresa la función booleana   F = A-B´C  como  suma  de miniterminos. La  fusión  tiene  tres variables  A,B,C. En  el primer termino, A, faltan  dos variables  por tanto  A esta  todavía  la falta  una variable.

                                   A= AB(C+C) + AB (C+C)

                                      = ABC+ABC+ABC+ABC

al Segundo termino, B´C le  falta  una variable :

                                    B´C=B´C(A+A)=AB´C+A´B´C

Al combinar  todos los términos  tenemos.

                                 F=A+BC

                                    = ABC + ABC +  ABC + ABC + A´B´C  .

Sin embargo  A´B´C  aparece  dos veces y, según  el teorema 1 (x+x=x), podemos  eliminar  uno  de ello. Después  de reacomodar  los  miniterminos  en orden ascendente. Obtenemos por fin.

                    F = A´B´C + AB´C´ + AB´C +  ABC´+ ABC

                     =m1 + m4  +  m6  +   m7

 Hay  ocasiones  en que  conviene  expresar  la función  booleana, en su forma  de suma  de miniterminos. Con  la siguiente  notación  abreviada.

 

             F(A,B,C) =                (1,4,5,6,7)

 

El símbolo de   representa OR    de los termino numéricos.

La  tabla  de verdad  que se  muestra  en la tabla   se deduce  directamente  de la expresión    algebraica  enumerado  las ocho  combinaciones  binarias  bajo  las  variables  A,B,C.

 

A            B              C               F

 

0             0               0                0

0             0               1                1

0             1               0                0

0             1               1                0

1             0               0                1

1             0               1                1

1             1               0                1

1             1               1                1

   

PRODUCTOS  DE MAXITERMINOS

Cada  una de las  2n  funciones   de n variables  binarias  se puede  expresar también  como  un producto  de maxiterminos  para  expresar  la fusión  booleana  como productos  de maxiterminos, primero debe  ponerse  en formato de términos OR  esto  podría  hacerse  con la ayuda  de la ley  distributiva , x + yz = (x+y)(x+z). Luego  se hace  el OR  de cualquier variable  faltante  x en cada  termino OR  con xx.

Un argumento  similar  demuestra  que la conversión  entre  el producto  de maxiterminos  y la  suma  de miniterminos  es similar. Ahora plantearemos  un procedimiento general de conversión. Para  convertir  de una forma cononica  a  otra  intercambiamos  los símbolos     y  П e incluimos  en la lista  solo  números que faltaban  en la forma original.

 Es posible convertir un función booleana  de una expresión  algebraica  a una producto  de  maxiterminos  utilizando  una tabla  de verdad  y el procedimiento de conversión  cononica.

   

F= xy + xz

 Primero obtenemos   la tabla de verdad  de la función, la cual  se muestra  en la tabla . los unos bajo  F en la tabla  se determina  a partir  de las  combinaciones  de las variables  en las  que  xy= 11 o zx = 01. de la tabla  de verdad  deducimos  que los  miniterminos  de la función  son  1,3  o y 7. la  función  expresada   como suma  de miniterminos  es :

                                        F(x,y,z) =     (1,3,6,7)

Puesto que  en total  hay  ocho  miniterminos  o maxiterminos  en una  función de tres  variables   deducimos que los términos faltante  son 0,2,4 y5. la función expresada  como productos  de maxiterminos es:

F(x,y,z) = П(0,,2,4,5) 

Esta  es la misma respuesta  que  obtuvimos  en el ejemplo anterior:

 x           y        z        F

0            0        0        0

0            0        1        1

0            1        0        0

0            1        1        1

1            0        0        0                 

1            0        1        0

1            1        0        1

1            1        1        1                          

**************************************************************************

¿Qué es Arduino?

Definir Arduino es complicado, muy complicado. Cuando hablamos de Android, por ejemplo, todos sabemos que se trata de un sistema operativo. Sin embargo, Android no es un único sistema operativo estático, cada fabricante lo implementa a su modo, e incluso la comunidad de desarrollo independiente ha puesto en Internet multitud de versiones del sistema operativo. Y hasta empresas como Nokia y Amazon utilizan Android sin siquiera mencionarlo.Algo similar a lo descrito en el párrafo anterior ocurre con Arduino. Se trata de un microcontrolador, una placa, un pequeño sistema de procesamiento. Sin embargo, su condición de sistema libre ha propiciado tantas variaciones de lo mismo, que Arduino no es una pieza de hardware única, y de hecho podemos encontrar tantas configuraciones como desarrolladores dispuestos a hacer cambios en los esquemas puedan existir.

¿Cómo funciona Arduino?

Como pasa con la mayoría de las placas microcontroladores las funciones de Arduino pueden resumirse en tres. En primera instancia, tenemos una interfaz de entrada, que puede estar directamente unida a los periféricos , o conectarse a ellos por puertos. El objetivo de esa interfaz de entrada es llevar la información al microcontrolador, la pieza encargada de procesar esos datos. El mentado microcontrolador varía dependiendo de las necesidades del proyecto en el que se desea usar la placa, y hay una buena variedad de fabricantes y versiones disponibles.Por último, tenemos una interfaz de salida, que lleva la información procesada a los periféricos encargadas de hacer el uso final de esos datos, que en algunos casos puede bien tratarse de otra placa en la que se centralizará y procesara nuevamente la información, o sencillamente, por ejemplo, una pantalla o un altavoz encargada de mostrar la versión final de los datos

CODIFICADORES Y DECODIFICADORES

DECODIFICADORES:

Son circuitos combinacionales de N entradas y un número de salidas menor o igual a 2n .Básicamente funciona de manera que al aparecer una combinación binaria en sus entradas, se activa una sola de sus salidas(no siempre).

CODIFICADORES:

Es un circuito combinacional formado por 2 a la n entradas y n salidas cuya función es tal que cuando una sola entrada adopta un determinado valor lógico (0 o 1, según las propiedades del circuito) las salidas representan en binario el número de orden de la entrada que adopte el valor activo.

EJERCICIO:

En este ejercicio representa un codificador de 4 entradas y 7 salidas en las cuales las entradas dan pulsos de 0 o 1 y en la salida se representa de manera binario el número que representa la combinación de estos pulsos de entrada.

Tabla de verdad que muestra el valor binario y el valor decimal.

Sw1	Sw2	Sw3	Sw4	binario
0	0	0	0	0
0	0	0	1	1
0	0	1	0	2
0	0	1	1	3
0	1	0	0	4
0	1	0	1	5
0	1	1	0	6
0	1	1	1	7
1	0	0	0	8
1	0	0	1	9

MATERIAL

          8 resistencias 220 homs
        1 display 8 segmentos cátodo común
         4 switch on/of
         Tablilla Protoboard
       Arduino Mega 2560 


CIRCUITO

CODIGO

 int Switch_1;
 int Switch_2;
 int Switch_3;
 int Switch_4;

 void setup()
{
  Serial.begin(9600);
  pinMode(31, OUTPUT);
  pinMode(32, OUTPUT);
  pinMode(33, OUTPUT);
  pinMode(34, OUTPUT);
  pinMode(35, OUTPUT);
  pinMode(36, OUTPUT);
  pinMode(37, OUTPUT);
  pinMode(27, INPUT);
  pinMode(28, INPUT);
  pinMode(29, INPUT);
  pinMode(30, INPUT);

}
void loop ()
{
  Switch_1 = digitalRead(27);
  Switch_2 = digitalRead(28);
  Switch_3 = digitalRead(29);
  Switch_4 = digitalRead(30);
  Serial.print(Switch_1);
  Serial.print(Switch_2);
  Serial.print(Switch_3);
  Serial.print(Switch_4);

//0//
 if((Switch_1 == LOW && Switch_2 == LOW && Switch_3 == LOW && Switch_4 == LOW))
  {
    digitalWrite(31,HIGH);digitalWrite(32,HIGH);digitalWrite(33,HIGH);
    digitalWrite(34,HIGH);digitalWrite(35,HIGH);digitalWrite(36,HIGH);
    digitalWrite(37,LOW);
  }
  else
 //1//
  {
  if((Switch_1 == LOW && Switch_2 == LOW && Switch_3 == LOW && Switch_4 == HIGH))
  {
       digitalWrite(36,LOW);digitalWrite(35,LOW);digitalWrite(37,LOW);
       digitalWrite(34,LOW);digitalWrite(33,LOW);
   }
   else
//2//
  {
  if((Switch_1 == LOW && Switch_2 == LOW && Switch_3 == HIGH && Switch_4 == LOW))
  {
       digitalWrite(36,HIGH);digitalWrite(31,HIGH);digitalWrite(37,HIGH);
       digitalWrite(34,HIGH);digitalWrite(33,HIGH);digitalWrite(32,LOW);
   }
   else
   //3//
  {
  if((Switch_1 == LOW && Switch_2 == LOW && Switch_3 == HIGH && Switch_4 == HIGH))
  {
       digitalWrite(36,HIGH);digitalWrite(31,HIGH);digitalWrite(37,HIGH);
       digitalWrite(32,HIGH);digitalWrite(33,HIGH);
   }
   else
   //4//
  {
  if((Switch_1 == LOW && Switch_2 == HIGH && Switch_3 == LOW && Switch_4 == LOW))
  {
       digitalWrite(35,HIGH);digitalWrite(37,HIGH);digitalWrite(31,HIGH);
       digitalWrite(32,HIGH);
   }
   else
   //5//
  {
  if((Switch_1 == LOW && Switch_2 == HIGH && Switch_3 == LOW && Switch_4 == HIGH))
  {
       digitalWrite(36,HIGH);digitalWrite(35,HIGH);digitalWrite(37,HIGH);
       digitalWrite(32,HIGH);digitalWrite(33,HIGH);
   }
   else
   //6//
  {
  if((Switch_1 == LOW && Switch_2 == HIGH && Switch_3 == HIGH && Switch_4 == LOW))
  {
       digitalWrite(32,HIGH);digitalWrite(33,HIGH);digitalWrite(34,HIGH);
       digitalWrite(35,HIGH);digitalWrite(36,HIGH);digitalWrite(37,HIGH);
   }
   else
   //7//
  {
  if((Switch_1 == LOW && Switch_2 == HIGH && Switch_3 == HIGH && Switch_4 == HIGH))
  {
       digitalWrite(36,HIGH);digitalWrite(31,HIGH);digitalWrite(32,HIGH);

   }
   else
   //8//
  {
  if((Switch_1 == HIGH && Switch_2 == LOW && Switch_3 == LOW && Switch_4 == LOW))
  {
       digitalWrite(31,HIGH);digitalWrite(32,HIGH);digitalWrite(33,HIGH);digitalWrite(34,HIGH);
       digitalWrite(35,HIGH);digitalWrite(36,HIGH);digitalWrite(37,HIGH);
  }
   else
   //9//
  {
  if((Switch_1 == HIGH && Switch_2 == LOW && Switch_3 == LOW && Switch_4 == HIGH))
  {
       digitalWrite(31,HIGH);digitalWrite(32,HIGH);
       digitalWrite(35,HIGH);digitalWrite(36,HIGH);digitalWrite(37,HIGH);
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }

conclusión

En esta practica entendemos el funcionamiento mediante 

combinación binaria de n entradas y  una salida como resultado de estos así comprendiendo lo que es circuitos codificadores y decodificadores.

------------------------------------------------------------------------------------------------

CIRCUITOS ARITMÉTICOS

 

DEFINICIÓN

Dentro de la variada gama de circuitos digitales, tenemos los denominados circuitos aritméticos. Estos tienen como objetivo realizar operaciones aritméticas en formato binario o BCD, punto fijo o punto flotante. Dependiendo de la aplicación se utilizarán unos u otros.

Son dispositivos MSI( Integración a Media Escala) que pueden realizar operaciones aritméticas (suma, resta, multiplicación y división) con números binarios. De todos los dispositivos, nos centraremos en los comparadores de magnitud, detectores y generadores de paridad, sumadores y ALU’s; (El diseño MSI surgió gracias a los avances en la tecnología de integración. Estos avances abarataron los costes de producción, y permitieron el desarrollo de circuitos más generales.)

MATERIALES

1 Display de 7 dígitos (cátodo común)

1 Resistencia 10KO

Arduino Mega 2560

1 Push boton

CIRCUITO

CÓDIGO

int pinBtnS = 3;
int pinA = 11;
int pinB = 10;
int pinC= 9;
int pinD = 8;
int pinE = 7;
int pinF = 6;
int pinG = 5;


int ANODOCOMUN = 0;
int CATODOCOMUN = 1;

int anterior = 0;
int estadoS = 0;
int estadoR = 0;
int number = 0;

void setup()
{
  pinMode(pinBtnS, INPUT);
  pinMode(pinA, OUTPUT);
  pinMode(pinB, OUTPUT);
  pinMode(pinC, OUTPUT);
  pinMode(pinD, OUTPUT);
  pinMode(pinE, OUTPUT);
  pinMode(pinF, OUTPUT);
  pinMode(pinG, OUTPUT);
}

void writeNumber(int number, int type = 1, int pinA = 11, int pinB = 10, int pinC = 9, int pinD = 8, int pinE = 7, int pinF = 6, int pinG = 5)
{
  switch(number)
  {
    default:
    case 0:
      if(type == 0)
      {
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, LOW);
        digitalWrite(pinC, LOW);
        digitalWrite(pinD, LOW);
        digitalWrite(pinE, LOW);
        digitalWrite(pinF, LOW);
        digitalWrite(pinG, HIGH);
      }

      break;

    case 1:
      if(type == 0)
      {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        digitalWrite(pinC, LOW);
        digitalWrite(pinD, HIGH);
        digitalWrite(pinE, HIGH);
        digitalWrite(pinF, HIGH);
        digitalWrite(pinG, HIGH);
      }
      break;

    case 2:
      if(type == 0)
      {
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, LOW);
        digitalWrite(pinC, HIGH);
        digitalWrite(pinD, LOW);
        digitalWrite(pinE, LOW);
        digitalWrite(pinF, HIGH);
        digitalWrite(pinG, LOW);
      }
      break;

    case 3:
      if(type == 0)
      {
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, LOW);
        digitalWrite(pinC, LOW);
        digitalWrite(pinD, LOW);
        digitalWrite(pinE, HIGH);
        digitalWrite(pinF, HIGH);
        digitalWrite(pinG, LOW);
      }
      break;

    case 4:
      if(type == 0)
      {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        digitalWrite(pinC, LOW);
        digitalWrite(pinD, HIGH);
        digitalWrite(pinE, HIGH);
        digitalWrite(pinF, LOW);
        digitalWrite(pinG, LOW);
      }
      break;

    case 5:
      if(type == 0)
      {
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        digitalWrite(pinC, LOW);
        digitalWrite(pinD, LOW);
        digitalWrite(pinE, HIGH);
        digitalWrite(pinF, LOW);
        digitalWrite(pinG, LOW);
      }
      break;

    case 6:
      if(type == 0)
      {
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        digitalWrite(pinC, LOW);
        digitalWrite(pinD, LOW);
        digitalWrite(pinE, LOW);
        digitalWrite(pinF, LOW);
        digitalWrite(pinG, LOW);
      }
      break;

    case 7:
      if(type == 0)
      {
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, LOW);
        digitalWrite(pinC, LOW);
        digitalWrite(pinD, HIGH);
        digitalWrite(pinE, HIGH);
        digitalWrite(pinF, HIGH);
        digitalWrite(pinG, HIGH);
      }
      break;
      case 8:
      if(type == 0)
      {
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, LOW);
        digitalWrite(pinC, LOW);
        digitalWrite(pinD, LOW);
        digitalWrite(pinE, LOW);
        digitalWrite(pinF, LOW);
        digitalWrite(pinG, LOW);
      }
      break;
    case 9:
      if(type == 0)
      {
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, LOW);
        digitalWrite(pinC, LOW);
        digitalWrite(pinD, LOW);
        digitalWrite(pinE, HIGH);
        digitalWrite(pinF, LOW);
        digitalWrite(pinG, LOW);
      }
      else
      break;
  }
}
void loop()
{
  estadoS = digitalRead(pinBtnS);
  if(estadoS && anterior == 0)
  {
    number++;
    if(number == 10)
      number = 0;
  }
  anterior = estadoS;
  writeNumber(number, ANODOCOMUN, pinA, pinB, pinC, pinD, pinE, pinF, pinG);
}

conclusión 

Mediante operaciones aritméticas (suma, resta, multiplicación y división) con números binarios damos señales apretando el switch así  comprendiendo las compuertas lógicas y su funcionamiento.

CIRCUITOS LÓGICOS DE TRES ESTADOS.

DEFINICIÓN  

Las señales lógicas se componen de dos estados normales, Alto y Bajo (1 o 0). Sin embargo, algunas salidas tienen un tercer estado eléctrico que no es un estado lógico, el cual se denomina estado de alta impedancia. En este estado, la salida se comporta como si aún no estuviera conectada al circuito, excepto por una pequeña corriente de fuga que puede fluir hacia adentro o hacia fuera de la Terminal de salida. Una salida puede tener uno de tres estados: 0 lógico, 1 lógico y de alta impedancia. Una salida con tres estados posibles se conoce como salida de tres estados o en ocasiones salida triestado. Los dispositivos de tres estados tienen una entrada extra, la cual se denomina generalmente “habilitación “o “Enable” para establecer las salidas del dispositivo en el estado de alta impedancia. Un bus de tres estados los cuales son comunes en equipos computacionales o control.

EJERCICIO 

Los circuitos lógicos de tres estados los podemos encontrar en el control de tráfico de un crucero de dos o más semáforos ya que mientras este uno de ellos funciona pone de manera enable o disable las otras salidas que controlan los otros semáforos.

MATERIALES

3 Diodos led (Verde, Amarillo y rojo)

3 resistencias de 220 hosm

Arduino Mega 2560

CIRCUITO

CÓDIGO

int tiempo1=5000;

int tiempo2=500;

int tiempo3=1000;

void setup() {

  pinMode(3, OUTPUT);

  pinMode(4, OUTPUT);

  pinMode(5, OUTPUT);

}

void loop() {

  digitalWrite(3,HIGH);

  delay (tiempo1);

  digitalWrite(3,LOW);

  delay (tiempo2);

  digitalWrite(3,HIGH);

  delay (tiempo2);

  digitalWrite(3,LOW);

  delay (tiempo2);

  digitalWrite(3,HIGH);

  delay (tiempo2);

  digitalWrite(3,LOW);

  digitalWrite(4,HIGH);

  delay (tiempo3);

  digitalWrite(4,LOW);

  digitalWrite(5,HIGH);

  delay (tiempo1);

  digitalWrite(5,LOW);

}

conclusión 

Creando un pequeño semáforo en un circuito Por medio de esta practica entendemos el funcionamiento de un semáforo el cual casi siempre vemos y respetamos cuando conducimos o cruzamos  la calle pero nunca sabemos como es que esta programado.

MULTIPLEXORES Y DEMULTIPLEXORES

DEMULTIPLEXORES
Un demultiplexor es un circuito lógico combinatorio que recibe información por una sola linea de entrada y transmite en una de las 2n lineas posibles de salida; la selección de una linea de salida especifica se controla por los valores de los bits de las "n" lineas de selección.

MULTIPLEXORES
Significa transmitir una gran cantidad de lineas o canales. Un multiplexor digital es un circuito combinatorio que selecciona información binaria de una de muchas lineas de entrada para dirigirla a una sola linea de salida.


 EJERCICIO

En este tutorial, vamos a mostrar cómo utilizar un 4051 mux / demux con tu Arduino. El IC 4051 es un multiplexor / demultiplexor analógico que se puede utilizar para conectar una entrada analógica a un pin de salida deseada. 




DIAGRAMA 

CÓDIGO

int Selpin [] = {14, 15, 16};  
int commonPin [] = {17, 18}; 
int llevó [] = {bajo, bajo, bajo, bajo, bajo, bajo, bajo, bajo};
int CdSVal [] = {0, 0, 0, 0};  
int cnt = 0;  
int persistDelay = 100;  
void setup () 
{ 
 Serial.begin (9600); 
for (int pin = 0; pin <3; pin ++) {(Selpin [pin], 
 OUTPUT); 
  } 
  } void loop ()
 { 
  flashLEDs (); si (== cnt 0) { for (int x; x <8; x ++) { LED [x] = aleatorio (2); } } ++ cnt; si (cnt> 100) {cnt = 0; 
  }
  } flashLEDs void ()
 {
  for (int pin = 0; pin <2; pin ++) { (commonPin [pin],

OUTPUT); 
digitalWrite (commonPin [pin], LOW); } for (int banco = 0; bancaria <4; bancaria ++) { for (int pin = 0; pin <3; pin ++) {// analizar fuera bits de selección de pin int señal = (banco >> pines) y 1; 
digitalWrite (Selpin [pin], la señal); } si (dirigido [banco * 2]) {// primero LED 
digitalWrite (commonPin [0], HIGH); // Convertir en común delayMicroseconds (persistDelay); // Permiso LED encendido  
digitalWrite (commonPin [0], LOW);  } si (dirigido [banco * 2 + 1]) { 
digitalWrite (commonPin [1], HIGH); delayMicroseconds (persistDelay); 
digitalWrite (commonPin [1], LOW); 
  }
  }
  }

CONCLUSIÓN

Con esta practica comprendemos mejor el concepto de los circuitos Multiplexores y demultiplexores trasmitiendo información dándoles salida por solo un pin de salida .

UNIDAD 5

CIRCUITOS SECUENCIALES

Un circuito cuya salida depende no solo de la combinación de entrada, sino también de la historia de las entradas anteriores se denomina Circuito Secuencial. Es decir aquellos circuitos en que el contenido de los elementos de memoria sólo puede cambiar en presencia de un pulso del reloj. Entre pulso y pulso de reloj, la información de entrada puede cambiar y realizarse operaciones lógicas en el circuito combinacional, pero no hay cambio en la información contenida en las células de memoria.

 

CIRCUITOS COMBINACIONALES

Un circuito combinacional es un circuito cuya salida es función exclusivamente del estado de sus entradas. Está compuesto por puertas lógicas y no deben presentar realimentación, es decir, ninguna salida de ningún componente debe usarse como entrada del circuito.
El comportamiento de un circuito secuencial se determina mediante las entradas, las salidas y los estados de sus flip-flops. Tanto las salidas como el estado siguiente son función de las entradas y del estado presente. El análisis de los circuitos secuenciales consiste en obtener una tabla o un diagrama de las secuencias de tiempo de las entradas, salidas y estados internos. También es posible escribir expresiones booleanas que describen el comportamiento de los circuitos secuenciales. Sin embargo, esas expresiones deben incluir la secuencia de tiempo necesaria ya sea en forma directa o indirecta.

FLIP-FLOP

Un flip flop es un circuito electrónico, llamado también simplemente biestable, que tiene dos estados estables. El flip flop es un elemento básico de memoria que es capaz de almacenar un número binario (bit), es decir, que permanece indefinidamente en uno de sus dos estados posibles aunque haya desaparecido la señal de excitación que provocó su transición al estado actual.

A continuación mostramos el código en arduino de un flip-flop

FLIP – FLOPS DISPARADOS POR FLANCO <ul><li>Los Flip – Flops son dispositivos síncronos, de dos estados, también conocidos como multivibradores biestables. Un Flip - Flop se diferencia de un Latch, en la forma en que cambian sus datos de salida, ya que es un dispositivo controlado por una señal de reloj, en el cual solamente cambiará sus datos de salida mientras ocurra un flanco de subida o de bajada de una señal de reloj, como lo indica la entrada dinámica. </li></ul>Indicador de Entrada Dinámica

3. FLIP-FLOP (S-R) Las entradas S y R de un Flip – Flop se denominan entradas síncronas, dado que los datos de estas entradas se transfieren a la salida del Flip-Flop sólo con el flanco de disparo del pulso de reloj. Cuando S está a nivel ALTO, y R está a nivel BAJO, la salida Q se pone a nivel ALTO con el flanco de disparo del pulso de reloj, pasando el Flip-Flop al estado SET. CLK S R Q Q̃ Símbolo lógico Flip-Flop S-R S R CLK Q ̃Q Comentarios 0 0 X NC NC No cambio 0 1 ↑ 0 1 RESET 1 0 ↑ 1 0 SET 1 1 ↑ 1 1 Condición no válida

4. FLIP-FLOP TIPO D Un Flip-Flop tipo D resulta muy útil cuando se necesita almacenar un único bit de datos (1 o 0). Si se añade un inversor a un Flip-Flop S-R obtenemos un Flip-Flop tipo D básico. CLK D Q Q̃ a) Con flando de subida b) Con flanco de bajada Símbolo lógico Flip-Flop Tipo D

5. FLIP-FLOP J-K Un Flip-Flop J-K es versátil y es uno de los tipos de Flip-Flop más utilizados, el funcionamiento de este Flip-Flop es idéntico al de un S-R en las condiciones de operación SET, RESET y de permanencia en estado NO Cambio. La diferencia está en que el Flip-Flop J-K no tiene condición no válida como ocurre en el S-R . El estado Toggle o de Basculación, lo que hace es tomar la frecuencia del reloj y dividirla en cada pico sucesivo del reloj, primero Q en ALTO y Q̃ en BAJO e inversamente.

CIRCUITOS SECUENCIALES:

El comportamiento de un circuito secuencial se determina mediante las entradas, las salidas y los estados de sus flip-flops. Tanto las salidas como el estado siguiente son función de las entradas y del estado presente. El análisis de los circuitos secuenciales consiste en obtener una tabla o un diagrama de las secuencias de tiempo de las entradas, salidas y estados internos. También es posible escribir expresiones booleanas que describen el comportamiento de los circuitos secuenciales. Sin embargo, esas expresiones deben incluir la secuencia de tiempo necesaria ya sea en forma directa o indirecta.

Un diagrama lógico se reconoce como el circuito de un circuito secuencial e incluye los flip-flops. Los flip-flops puede ser cualquier tipo y el diagrama lógico puede o no incluir compuertas combinacionales. 

CONTADORES:

Un contador es un circuito secuencial de aplicación general, cuyas salidas representan en un determinado código el numero de pulsos que se meten a la entrada

Están constituidos por una serie de biestables conectados entre si de modo que las salidas de estos cambian de estado cuando se aplican impulso. a la entrada.

La capacidad de un contador es el numero mas elevado, expresado en cualquiera de los códigos binarios, que puede ser representado en sus salidas.

El modulo, o número de estados totales que puede representar el contador, es igual al numero máximo de impulsos que se puede representar más uno (el cero). Si "n" es el número de flip‑flops empleado para hacer el contador, y "M" el módulo del contador, se debe verificar:           

                                                          M ≤ 2”

Cuando el contador llega al valor máximo de su capacidad, comienza a contar de nuevo desde cero al aplicarle el siguiente impulso.

Dependiendo del  modo d e operación, lo s contadores pueden ser ascendentes ( si su contenido se incrementa con cada impulso), descendentes (si su contenido disminuye), o bien una combinación de ambos (up/down counters).

Por otro lado, los contadores se dividen en sÍncronos y asíncronos. Los primeros, son aquellos en los que los impulsos de reloj se aplican simultáneamente a todos los biestables, y por tanto, todas las salidas cambian al mismo tiempo.

En los asíncronos, por contra, la señal de reloj se aplica a la entrada del primer biestable, la salida de éste a la entrada de reloj del siguiente, y así sucesivamente el tiempo de propagación de estos dispositivos, es superior al de los sÍncronos (la señal tiene que pasar por todos los bits menos significativos hasta llegar a un determinado bit).

Otra clasificación es según la naturaleza de los números que cuenta el dispositivo. Existen contadores binarios (el número de estados es múltiplo de 2), decimales (el numero de estados es múltiplo de 10), y de modulo M (un numero M cualquiera de estados).

Además, en todos los casos anteriores, la cuenta no tiene por qué empezar e terminar en 0. Por ejemplo se puede diseñar un contador de módulo 3 que cuente 5‑6‑7.

El diseño de contadores sÍncronos, se hace de igual forma que para cualquier circuito secuencial. Como caso particular, vamos a ver el diseño de contares binarios asíncronos.

PRACTICA

Se realizó la practica de un contador en la que la secuencia era en retroceso y en numero nones, empezando en 9,7,5,3,1 y volvía a empezar.

MATERIAL

-Arduino 
-8 resistencias de 220 homs
-1 display de 8 entradas

CODIGO 
const int a = 2;
const int b = 3;
const int c = 4;
const int d = 5;
const int e = 6;
const int f = 7;
const int g = 8;

 void setup() {
   pinMode (a, OUTPUT);
   pinMode (b, OUTPUT);
   pinMode (c, OUTPUT);
   pinMode (d, OUTPUT);
   pinMode (e, OUTPUT);
   pinMode (f, OUTPUT);
   pinMode (g, OUTPUT);
}

 void loop() {
//9
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
delay(500);
//7
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, LOW);
delay(500);

//5
digitalWrite(a, HIGH);
digitalWrite(b, LOW);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, LOW);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
delay(500);

//3
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, HIGH);
delay(500);


//1
digitalWrite(a, LOW);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, LOW);
delay(500);
}

CONCLUSIÓN

Con esta practica del arduino se comprendió  la secuencia en retroceso de números nones  mediante un contador teniendo en claro como funciona un circuito secuencial y los contadores.