martes, 29 de septiembre de 2015

PRACTICA 4 MULTIPLEXOR


              
SEPTIEMBRE 2015

OBJETIVO:
Conocer el funcionamiento de un multiplexor a través de una simulación con la tarjeta Arduino.
INTRODUCCIÓN:
MULTIPLEXOR
Multiplexar significa transmitir una gran cantidad de canales o líneas. Un Multiplexor digital es un circuito combinatorio que selecciona información binaria de una de muchas líneas de entrada para dirigirla a una sola línea de salida. La selección de una línea de entrada en particular es controlada por el conjunto de líneas de selección, normalmente hay 2n líneas de entrada y 1 línea de salida. Un Multiplexor se llama también selector de datos, ya que selección a una de muchas entradas y guía la información binaria a la línea de salida.
Normalmente los Multiplexores tienen una entrada de habilitación (strube), esta puede ser utilizada para expandir un arreglo de Multiplexor es mediante circuitos integrados líneas de entrada limitado.
Un multiplexor (MUX) es un circuito combinacional al que entran varios canales de datos, y sólo salen los datos del que hayamos seleccionado, es decir, un circuito que nos permite seleccionar que datos pasan a través de dicho componente.
DIAGRAMA:
CÓDIGO:
  • Código para realizar las combinaciones posibles de salida.
void setup()
{
  pinMode(13, OUTPUT);
  pinMode(12, OUTPUT);
  pinMode(11, OUTPUT);
}

void loop()
{
  int t=1000;

  digitalWrite(13, LOW);  
  digitalWrite(12, LOW);
  digitalWrite(11, LOW);
  delay(t);

  digitalWrite(13, LOW);  
  digitalWrite(12, LOW);
  digitalWrite(11, HIGH);
  delay(t);
 
  digitalWrite(13, LOW);  
  digitalWrite(12, HIGH);
  digitalWrite(11, LOW);
  delay(t);
 
  digitalWrite(13, LOW);  
  digitalWrite(12, HIGH);
  digitalWrite(11, HIGH);
  delay(t);
 
  digitalWrite(13, HIGH);  
  digitalWrite(12, LOW);
  digitalWrite(11, LOW);
  delay(t);

  digitalWrite(13, HIGH);  
  digitalWrite(12, LOW);
  digitalWrite(11, HIGH);
  delay(t);

  digitalWrite(13, HIGH);  
  digitalWrite(12, HIGH);
  digitalWrite(11, LOW);
  delay(t);
 
  digitalWrite(13, HIGH);  
  digitalWrite(12, HIGH);
  digitalWrite(11, HIGH);
  delay(t);

}

  • Código para realizar la función de un multiplexor de dos entradas.

void setup()
{
  pinMode(13, INPUT);
  pinMode(12, INPUT);
  pinMode(11, INPUT);
  pinMode(10, OUTPUT);
}

void loop()
{
 int t=500;

  int a=digitalRead(13);
  int b=digitalRead(12);
  int c=digitalRead(11);
 
  if(a==0 && b==0 && c==0)
  {
   digitalWrite(10, LOW);
  }

  if(a==0 && b==0 && c==1)
  {
   digitalWrite(10, HIGH);
  }      

  if(a==0 && b==1 && c==0)
  {
   digitalWrite(10, LOW);
  }     

   if(a==0 && b==1 && c==1)
  {
   digitalWrite(10, HIGH);
  }      

  if(a==1 && b==0 && c==0)
  {
   digitalWrite(10, LOW);
  }      

  if(a==1 && b==0 && c==1)
  {
   digitalWrite(10, LOW);
  }      

  if(a==1 && b==1 && c==0)
  {
   digitalWrite(10, HIGH);
  }      

  if(a==1 && b==1 && c==1)
  {
   digitalWrite(10, HIGH);
  }      

}

  • Código para realizar la función del multiplexor de cuatro entradas.

RESULTADOS:
Dos entradas.


Cuatro entradas.












CONCLUSIONES:
Rosa María Cortés Herrera:
Esta práctica fue muy complicada de realizar, ya que hacer el código cambio en comparación de las otras prácticas, esto fue debido a la dificultad que implicaba meter 4 entradas y estas a su vez involucraba tener 64 combinaciones, realizar el código fue un reto para el equipo y en lo personal también, sin embargo, comprendí de una manera más grafica como funciona un multiplexor, ya que en cursos anteriores lo habíamos visto de una manera teórica. Personalmente la práctica logro que comprendiera el tema y aprendí de ella.    
Cynthia Allen Espinosa:
Para esta práctica, se simulo el funcionamiento de varias entradas y salidas las cuales representan un bit cada una, estas cambian de acuerdo a una tabla que es generada con unos y ceros. Se utilizaron dos Arduino, uno es configurado con las entradas mientras que el otro recibe estas y da como resultado una salida. Lo complicado esta vez, fue utilizar ciclos pues es diferente ya implementado con hardware.
Yessica Morales González:
En esta práctica aprendimos como es el comportamiento de un multiplexor simulando su funcionamiento dos tarjetas Arduino en la que una funcionaba como entrada y la otra recibía los datos y nos daba una salida de acuerdo a su función. También nos dimos cuenta de que al realizar combinaciones de código podemos representar la función de cualquier multiplexor con dos o cuatro entradas.
Vanessa Madelin Pacheco Trejo:
Con esta práctica aprendimos a realizar combinaciones de entradas y salidas con dos diferentes Arduino, pudimos ver cómo se puede realizar esas combinaciones para que ambas recibieran señal en base a la programación que dábamos para cada entrada o bien salida así como la observación de su comportamiento.
Eduardo Armando Ramos Montiel:
Esta práctica nos demostró el funcionamiento de un multiplexor el cual permite seleccionar uno de todos los datos que entran y mostrarlo a la salida, esto lo llevamos a cabo gracias a la combinación de 1 y 0 que controlan nuestro circuito (Controladores).Así como la obtención de una tabla de verdad la cual nosotros planteamos y aplicamos tanto practica como teóricamente, y así retroalimentar el conocimiento teórico que ya se tenía


REFERENCIAS:
Aguilar Meza Celedonio E., Circuitos Digitales (Multiplexores y Demultiplexores). Obtenido de: http://aguilarmicros.mex.tl/imagesnew2/0/0/0/0/2/1/4/2/9/6/Mux_De.pdf
Botero Henao Oscar Ignacio, Circuitos Multiplexores y Demultiplexores. Obtenido de: https://www.academia.edu/13760975/Mux_Demux_Circuitos_Integrados_Multiplexores


PRÁCTICA 3 - DECODIFICADOR

OBJETIVOS
·         Observar y experimentar con ayuda de unos LEDs el funcionamiento de la tarjeta Arduino en conexión con otra tarjeta.
·          Establecer secuencias de encendido con LEDs.
·         Lograr que los circuitos integrados generen las funciones deseadas.
·         Comprobar la tabla de verdad para obtener las funciones de salida deseadas.

MATERIAL
·         Tarjeta Arduino UNO.
·         5 o más LEDs.
·         Resistencias de 220 o 330 ohms.
·         Cables para conexión.




CÓDIGOS A IMPLEMENTAR

CÓDIGO QUE ENVIA LOS DATOS Y LOS RECIBE EN LA MISMA TARJETA
void setup()
{
  pinMode(13,OUTPUT);
  pinMode(12,OUTPUT);
  pinMode(11,OUTPUT);
  pinMode(10,OUTPUT);
  pinMode(9,OUTPUT);
  pinMode(8,OUTPUT);
  pinMode(7,OUTPUT);
  pinMode(6,OUTPUT);
  pinMode(5,INPUT);
  pinMode(4,INPUT);
  pinMode(3,INPUT);
 
}

void loop()
{
  int t=2000;

  int a=digitalRead(5);
  int b=digitalRead(4);
  int c=digitalRead(3);
 
  if(a==0 && b==0 && c==0)
  {
   digitalWrite(13, LOW);
   digitalWrite(12, HIGH);
   digitalWrite(11, HIGH);
   digitalWrite(10, HIGH);
   digitalWrite(9, HIGH);
   digitalWrite(8, HIGH);
   digitalWrite(7, HIGH);
   digitalWrite(6, HIGH);
   delay(t);
  }

  if(a==0 && b==0 && c==1)
  {
   digitalWrite(13, HIGH);
   digitalWrite(12, LOW);
   digitalWrite(11, HIGH);
   digitalWrite(10, HIGH);
   digitalWrite(9, HIGH);
   digitalWrite(8, HIGH);
   digitalWrite(7, HIGH);
   digitalWrite(6, HIGH);
   delay(t);
  }      

  if(a==0 && b==1 && c==0)
  {
   digitalWrite(13, HIGH);
   digitalWrite(12, HIGH);
   digitalWrite(11, LOW);
   digitalWrite(10, HIGH);
   digitalWrite(9, HIGH);
   digitalWrite(8, HIGH);
   digitalWrite(7, HIGH);
   digitalWrite(6, HIGH);
   delay(t);
  }     

   if(a==0 && b==1 && c==1)
  {
   digitalWrite(13, HIGH);
   digitalWrite(12, HIGH);
   digitalWrite(11, HIGH);
   digitalWrite(10, LOW);
   digitalWrite(9, HIGH);
   digitalWrite(8, HIGH);
   digitalWrite(7, HIGH);
   digitalWrite(6, HIGH);
   delay(t);
  }      

  if(a==1 && b==0 && c==0)
  {
   digitalWrite(13, HIGH);
   digitalWrite(12, HIGH);
   digitalWrite(11, HIGH);
   digitalWrite(10, HIGH);
   digitalWrite(9, LOW);
   digitalWrite(8, HIGH);
   digitalWrite(7, HIGH);
   digitalWrite(6, HIGH);
   delay(t);
  }      

  if(a==1 && b==0 && c==1)
  {
   digitalWrite(13, HIGH);
   digitalWrite(12, HIGH);
   digitalWrite(11, HIGH);
   digitalWrite(10, HIGH);
   digitalWrite(9, HIGH);
   digitalWrite(8, LOW);
   digitalWrite(7, HIGH);
   digitalWrite(6, HIGH);
   delay(t);
  }      

  if(a==1 && b==1 && c==0)
  {
   digitalWrite(13, HIGH);
   digitalWrite(12, HIGH);
   digitalWrite(11, HIGH);
   digitalWrite(10, HIGH);
   digitalWrite(9, HIGH);
   digitalWrite(8, HIGH);
   digitalWrite(7, LOW);
   digitalWrite(6, HIGH);
   delay(t);
  }      

  if(a==1 && b==1 && c==1)
  {
   digitalWrite(13, HIGH);
   digitalWrite(12, HIGH);
   digitalWrite(11, HIGH);
   digitalWrite(10, HIGH);
   digitalWrite(9, HIGH);
   digitalWrite(8, HIGH);
   digitalWrite(7, HIGH);
   digitalWrite(6, LOW);
   delay(t); 
  }      
}

CAPTURAS
















CONCLUSIONES

Rosa María Cortés Herrera
En esta práctica lo primero a realizar fue relativamente fácil ya que eran pocas entradas y con la ayuda de un segundo arduino pudimos realizar un código eficaz, aunque al principio se nos complicó ya que por falta de un arduino se decidió que una sola placa funcionara tanto para las entradas y las salidas. Después se tuvo que realizar una extensión de la práctica pero aumentando considerablemente el número de entradas y por consiguiente las salidas, para esta nos ayudamos en el código con algunos for e if  que fueron de gran utilidad, al final la práctica se realizó exitosamente.

Cynthia Allen Espinosa
En esta práctica aprendimos con detalle cómo funcionan los circuitos integrados al momento en que se envían impulsos a través de ellos, conocimos de qué forma se pueden realizar diferentes combinaciones para obtener salidas diferentes correspondientes a la tabla de verdad que teníamos desarrollada.

Yessica Morales González
En esta práctica se implementó el funcionamiento de un decodificador de tres entradas con ocho salidas, en la cual primero se realizó una simulación con dos tarjetas Arduino, una funcionaba como las entradas y la otra recibía esos parámetros y mostraba las salidas correspondientes. Para la otra parte de la práctica utilizamos la tarjeta Arduino que nos daba las entradas y esta la conectamos a un decodificador (circuito integrado), al conectarlo con la tarjeta nos daba las ocho salidas correspondientes a la tabla de verdad del decodificador.

Eduardo Ramos Montiel
Al desarrollar esta práctica se pudo observar que la tarjeta Arduino puede funcionar y utilizarse dentro de circuitos que estén haciendo uso de diferentes componentes, en este caso los circuitos integrados, pudimos observar que al combinar estos dos componentes, se pueden construir diferentes aplicaciones electrónicas como el decodificador que desarrollamos, ya que tenía entradas definidas y esperábamos cierta salida, fue complicado entender la manera en que los circuitos integrados transfieren los datos dentro de sí mismos.

Vanessa Pacheco Trejo

A partir de esta práctica pude observar que se pueden obtener diferentes funciones de salida a partir de un número determinado de entradas, observamos el funcionamiento de un circuito integrado decodificador y como es que interpreta la información que nosotros le enviamos. 



PRÁCTICA 2 - COMPUERTAS

OBJETIVOS
·         Observar y experimentar con ayuda de unos LEDs el funcionamiento de la tarjeta Arduino en conexión con otra tarjeta.
·          Establecer secuencias de encendido con LEDs.
·         Comprobar la tabla de verdad para obtener las funciones de salida deseadas

MATERIAL
·         2 Tarjetas Arduino UNO.
·         5 o más LEDs.
·         Resistencias de 220 o 330 ohms.
·         Cables para conexión.

DIAGRAMAS





CÓDIGOS A IMPLEMENTAR

FUNCIÓN QUE GENERA LA TABLA DE VERDAD

void setup()
{
  pinMode(13, OUTPUT);
  pinMode(12, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(9, OUTPUT);
}

void loop()
{
  int t=100;
  digitalWrite(13, HIGH);
  delay(t);
  digitalWrite(12, HIGH);
  delay(t);
  digitalWrite(11, HIGH);
  delay(t);
  digitalWrite(10, HIGH);
  delay(t);
  digitalWrite(9, HIGH);
  delay(t);

  digitalWrite(13, LOW);
  delay(t);
  digitalWrite(12, LOW);
  delay(t);
  digitalWrite(11, LOW);
  delay(t);
  digitalWrite(10, LOW);
  delay(t);
  digitalWrite(9, LOW);
  delay(t);

  digitalWrite(9, HIGH);
  delay(t);
  digitalWrite(10, HIGH);
  delay(t);
  digitalWrite(11, HIGH);
  delay(t);
  digitalWrite(12, HIGH);
  delay(t);
  digitalWrite(13, HIGH);
  delay(t);

  digitalWrite(9, LOW);
  delay(t);
  digitalWrite(10, LOW);
  delay(t);
  digitalWrite(11, LOW);
  delay(t);
  digitalWrite(12, LOW);
  delay(t);
  digitalWrite(13, LOW);
  delay(t);



  digitalWrite(13, HIGH);
  delay(t);
  digitalWrite(12, HIGH);
  delay(t);
  digitalWrite(11, HIGH);
  delay(t);
  digitalWrite(10, HIGH);
  delay(t);
  digitalWrite(9, HIGH);
  delay(t);

  digitalWrite(9, LOW);
  delay(t);
  digitalWrite(10, LOW);
  delay(t);
  digitalWrite(11, LOW);
  delay(t);
  digitalWrite(12, LOW);
  delay(t);
  digitalWrite(13, LOW);
  delay(t);


}

}

CÓDIGO QUE INTERPRETA LA TABLA DE VERDAD (PRIMER CIRCUITO)
void setup()
{
  pinMode(13, INPUT);
  pinMode(12, INPUT);
  pinMode(11, INPUT);
  pinMode(10, OUTPUT);
}

void loop()
{
 t=1000;
 
  if(13==0 && 12==0 && 11==0)
  {
   digitalWrite(10, LOW);
   delay(t);
  }

  if(13==0 && 12==0 && 11==1)
  {
   digitalWrite(10, HIGH);
   delay(t);
  }      

  if(13==0 && 12==1 && 11==0)
  {
   digitalWrite(10, LOW);
   delay(t);
  }     

   if(13==0 && 12==1 && 11==1)
  {
   digitalWrite(10, HIGH);
   delay(t);
  }      

  if(13==1 && 12==0 && 11==0)
  {
   digitalWrite(10, LOW);
   delay(t);
  }      

  if(13==1 && 12==0 && 11==1)
  {
   digitalWrite(10, LOW);
   delay(t);
  }      

  if(13==1 && 12==1 && 11==0)
  {
   digitalWrite(10, LOW);
   delay(t);
  }      

  if(13==1 && 12==1 && 11==1)
  {
   digitalWrite(10, HIGH);
   delay(t);
  }      


}

CÓDIGO QUE INTERPRETA LA TABLA DE VERDAD (SEGUNDO CIRCUITO)
void setup()
{
  pinMode(13, INPUT);
  pinMode(12, INPUT);
  pinMode(11, INPUT);
  pinMode(10, OUTPUT);
}

void loop()
{
 t=2000;
 
  if(13==0 && 12==0 && 11==0)
  {
   digitalWrite(10, HIGH);
   delay(t);
  }

  if(13==0 && 12==0 && 11==1)
  {
   digitalWrite(10, LOW);
   delay(t);
  }      

  if(13==0 && 12==1 && 11==0)
  {
   digitalWrite(10, LOW);
   delay(t);
  }     

   if(13==0 && 12==1 && 11==1)
  {
   digitalWrite(10, HIGH);
   delay(t);
  }      

  if(13==1 && 12==0 && 11==0)
  {
   digitalWrite(10, HIGH);
   delay(t);
  }      

  if(13==1 && 12==0 && 11==1)
  {
   digitalWrite(10, HIGH);
   delay(t);
  }      

  if(13==1 && 12==1 && 11==0)
  {
   digitalWrite(10, LOW);
   delay(t);
  }      

  if(13==1 && 12==1 && 11==1)
  {
   digitalWrite(10, LOW);
   delay(t);
  }      


}
CAPTURAS












CONCLUSIONES

Rosa María Cortés Herrera
De esta práctica aprendí que el utilizar compuertas lógicas   (componentes) y el arduino, es mucho más sencillo y rápido el armado de circuitos. Esto debido a que en cursos anteriores se habían realizado circuitos parecido referentes a su función pero el armado era más complicado demasiado enredado debido al uso de cables y otros tantos componentes que hacían más laborioso su armado, realizar el código en lo personal me ayudo a recordar y repasar el uso de las tablas de verdad de cada una de las compuertas (not, and, or, etc.)

Cynthia Allen Espinosa
Para esta práctica se utilizaron dos tarjetas Arduino para poder simular compuertas lógicas, la complicación se dio cuando teníamos que programar las entradas y salidas de ambas tarjetas y hacerlas funcionar de la manera esperada, todo esto hablando en términos de la programación.

Yessica Morales González
En esta práctica implementamos un código para simular las funciones de acuerdo a sus entradas y obteniendo salidas de acuerdo a las tablas de verdad que construimos para cada caso, luego lo hicimos mediante el uso de compuertas and y not(circuitos integrados) conectándolas correctamente a las entradas que una tarjeta Arduino nos daba y también a una salida, comprendimos como realizaba el proceso y como nos daba una salida que por supuesto se daba en cada caso según la función que correspondía.

Eduardo Ramos Montiel
Al implementar esta práctica pudimos darnos cuenta de que las tarjetas Arduino tienen diferentes aplicaciones dentro de la electrónica, ya que pueden simular compuertas lógicas de la misma manera en que lo hacen algunos circuitos y es posible hacerlo gracias a que la programación de las tarjetas está diseñada para funcionar como el lenguaje C.

Vanessa Pacheco Trejo

Al completar esta práctica pude notar que las tarjetas Arduino tienen un gran potencial si se trata de construir cierto tipo de circuitos, la parte más interesante fue descubrir que para lograr que la tarjeta actúe de la  manera deseada, no hace falta tener grandes conocimientos de programación ni de electrónica; la práctica pudo finalizarse después de haber resuelto el problema de la programación en dos diferentes tarjetas.