jueves, 30 de julio de 2015

Cruce de semáforos LED (Salidas TRI – Estado)

Materiales
-2 x Diodo LED Red
-2 x Diodo LED Yellow
-2 x Diodo LED Green
-6 x Resistencia 220 ohmios
-1 x Resistencia 10 Kohmios
-1 x Arduino UNO
-Cables
-1 x boton



Los LEDs los conectaremos desde la salida de la resistencia hacia el controlador. (ver imagen)

- LED Verde (derecha): PIN 2 del Arduino.
- LED Amarillo: PIN 3 (PWM)
- LED Rojo: PIN 4
- LED Verde: PIN 5
- LED Amarillo: PIN 6
- LED Rojo: PIN 7
  

Programación

const int button = 8;

void setup() {
 for (int pin = 2; pin <= 7; pin++) {
   pinMode(pin, OUTPUT);
 }
 pinMode(button, INPUT);
}

void semaphoreOne() {
 digitalWrite(2, HIGH);
 int count = 0;
 while (count < 30) {

   if (digitalRead(button) == true) {
     break;
   }
   count++;
   delay(200);
 }
  digitalWrite(2, LOW);
 delay(500);
 digitalWrite(2, HIGH);
 delay(500);
 digitalWrite(2, LOW);
 delay(500);
 digitalWrite(2, HIGH);
 delay(500);
 digitalWrite(2, LOW);
 delay(500);
 digitalWrite(2, HIGH);
 delay(500);
 digitalWrite(2, LOW);
 delay(500);
 digitalWrite(2, HIGH);
 delay(500);
 digitalWrite(2, LOW);
 digitalWrite(3, HIGH);
 delay(2500);
 digitalWrite(3, LOW);
 digitalWrite(4, HIGH);
 digitalWrite(7, LOW);
  semaphoreTwo();
}

void semaphoreTwo() {
 digitalWrite(5, HIGH);
 int count = 0;
 while (count < 30) {
   if (digitalRead(button) == true) {
     break;
   }
   count++;
   delay(200);
 }
 digitalWrite(5, LOW);
 delay(500);
 digitalWrite(5, HIGH);
 delay(500);
 digitalWrite(5, LOW);
 delay(500);
 digitalWrite(5, HIGH);
 delay(500);
 digitalWrite(5, LOW);
 delay(500);
 digitalWrite(5, HIGH);
 delay(500);
 digitalWrite(5, LOW);
 delay(500);
 digitalWrite(5, HIGH);
 delay(500);
 digitalWrite(5, LOW);
 digitalWrite(6, HIGH);
 delay(2500);
 digitalWrite(6, LOW);
 digitalWrite(7, HIGH);
 digitalWrite(4, LOW);
 semaphoreOne();
}

void loop() {
 for (int pin = 2; pin <= 7; pin++) {
   digitalWrite(pin, LOW);
 }
 digitalWrite(2, HIGH);
 digitalWrite(7, HIGH);
 semaphoreOne();
}

Conclusión

Con esta actividad podemos realizar diferentes operaciones continuas programadas con un semáforo o programar una máquina, es de gran utilidad al hacer actividades secuenciales ya que puedes programar por tiempo en cuanto termine una inicia la otra actividad en este caso son las luces de un semáforo de crucero, en este puedes escoger el tiempo de encendido y de apagado.  

domingo, 26 de julio de 2015

Circuitos aritmerticos

Circuito aritmético
La conexión del circuito es bastante sencilla, simplemente conectamos la salida digital del arduino al lado positivo del LED poniendo entre medias unas resistencias de 330 ohm´s, mientras que el lado negativo de cada LED iría al la conexión de tierra del Arduino.



Como se ve en el esquema.
Montándolo en la placa protoboard, a mí me ha quedado algo así:


Una vez tenemos el circuito montado, viene la parte de la programación, antes de nada hay que descargarse el entorno de programación del Arduino.
El código en cuestión sería algo como:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
int outPin[] = {13, 12, 11, 10, 9};

int delayValue = 600;

void setup()
{
  int i = 0;
  for ( i = 0; i < 5; i++)
    pinMode(outPin[i], OUTPUT);
}

void loop()
{

  int i = 0, j=0;

  for ( i = 0; i < 32; i++)
  {
     for ( j = 0; j < 5; j++)
     {
       if ( ( (i >> j) & 1 )  == 1 )
           digitalWrite(outPin[j], HIGH);
       else digitalWrite(outPin[j], LOW);
     }
     delay(delayValue);
  }
}
Es bastante sencillo, declaramos un array con el conjunto de pines a los cuales están conectados nuestros LEDs. En la función setup, los configuramos en modo salida.
Está en la función loop(), esta se ejecutará una y otra vez, lo que hacemos es iterar por los 32 numeros que podemos mostrar, ya que tenemos 5 LEDs, y 2 elevados a 5 son 32. Por cada número, encendemos o apagamos cada led correspondiente. La clave está en el bucle que realiza la operación “(i >> j) & 1″. Cada iteración del bucle divide el numero en cuestion por 2 y se queda unicamente con el bit de menor valor. Asi sabemos si tenemos que encender o no el LED.
Por ejemplo, para mostrar el número 21, que en binario es (10101) deberiamos encender los LEDs 0, 2 y 4 y dejar apagados el resto. El calculo sería:
·         LED 0: 21 (10101 & 1) -> 1 , encendido
·         LED 1: 21 / 2 = 10 (01010 & 1) -> 0, apagado
·         LED 2: 21 / 4 = 5 (00101 & 1) -> 1, encendido
·         LED 3: 21 / 8 = 2 (00010 & 1) -> 0, apagado
·         LED 4: 21 / 16 = 1 (00001 & 1) -> 1, encendido
Como vemos, el resultado del calculo es correcto. Básicamente lo que se hace es ir desplazando los bits hacia la derecha y quedandonos con el bit menos significativo.

Conclucion

En esta practica pode realizar sumas secuenciales las que ayudan en diferentes casos segun lo requeramos podemos ir sumando numero de 2 en 2 o ir restando para realizar diferentes actividades ya sea para mostrar un marcador o para realiazar un conteo.

viernes, 24 de julio de 2015

Comparador de magnitudes

Comparadores de magnitud

Un comparador de magnitud es un circuito combinacional que compara dos números, A y B y determina sus magnitudes relativas. La salida de la comparación se especifica por tres variables binarias que indican si A>B, A=B o A
Para determinar si A es mayor o menor que B, se inspeccionan las magnitudes relativas de pares de dígitos significativos empezando desde la posición mas significativa. Si los dos dígitos son iguales, el par de dígitos de la siguiente posición significativa más baja se comparan. Esta comparación continúa hasta que se alcanza un par de dígitos desiguales. Si el dígito correspondiente de A es 0 y B es 1, se tiene que A < B.
Funciones para A mayor o menor que B La comparación secuencial puede expresarse en forma lógica por las siguientes dos funciones booleanas:
(A>B)= A3B3’ + A2B2’X3 + A1B1’X3X2 + A0B0’X3X2X1
(A<B)= A3’B3 + A2’B2X3 + A1’B1X3X2 + A0’B0X3X2X1

Circuito Comparador
Los circuitos comparadores son integrados que se encargan de evaluar dos números en sistema binario conformados por cuatro dígitos cada uno. Dichos circuitos nos informan si los números son diferentes o iguales por medio de tres salidas.


La siguiente imagen contiene un esquema que indica el orden de los pines de la referencia mas común de integrados comparadores que es la 7485.


Construccion de circuito




Materiales

·          - Circuito integrado 7485
·         - 3 led’s
·         - 3 resistencias de 330 Ω
·         - Interruptor de 8 vías (Nosotros lo haremos programando los pulsos en el arduino)
·         Arduino

Descripción
En este proyecto vamos a construir un sistema comparador, este se encarga de comparar 2 números en su sistema binario con un interruptor de 8 vías creando los pulsos ya sean high o Low correspondiendo a “0” y a “1”. Este interruptor lo vamos a sustituir con la tablilla arduino ya que con este dispositivo puedes generar dichos pulsos sin la necesidad de utilizar un interruptor.


Estas son entradas del circuito integrado estas van a estar a los pines 15, 13, 12, 10 ya que son aquí donde vamos introducir los pulsos binarios que uniéndolos van a ser el primer número a comparar.
En las entradas 1, 14, 11, 9 es donde vamos a introducir los pulsos binarios del segundo número.

Los pines 5, 6, 7 son las salidas donde nos va comparar los 2 números introducíos en en las entradas y nos dira si “es mayor que”, “Menor que” y una “igualdad”. En el pin 5 será “A>B” en el 5 abra “A=B” y en el 7 “A<B”. Estas salidas irán conectadas a 3 led los cuales nos indicaran cual de la 3 salidas se activó.
Posición de los switch
A=0001
B=0010
A<B Se enciende el tercer led




A=0010
B=0001
A>B Se enciende el primer led




A=0010
B=0010
A=B se enciende el led de en medio

Arduino
En arduino vamos a programar los pulsos binarios  que van salir para convertirlos en números binarios y compararlos y así decidir cuál es mayor según el circuito integrado y los led indicadores.
Las salidas 22, 24, 26, 28 irán conectadas al circuito integrado en los pines 15, 13, 12, 10
Las salidas 31, 33, 35, 37 irán conectadas al circuito integrado en los pines 1, 14, 11, 9

int a1=22;
int a2=24;
int a3=26;
int a4=28;
//Primer número que sería el numero A
int b1=31;
int b2=33;
int b3=35;
int b4=37;
//Segundo numero B
 void setup(){
   pinMode(a1, OUTPUT);
   pinMode(a2, OUTPUT);
   pinMode(a3, OUTPUT);
   pinMode(a4, OUTPUT);
   pinMode(b1, OUTPUT);
   pinMode(b2, OUTPUT);
   pinMode(b3, OUTPUT);
   pinMode(b4, OUTPUT);
 }
 void loop()
 {
   digitalWrite(a1,HIGH);
   digitalWrite(a2,LOW);
   digitalWrite(a3,LOW);
   digitalWrite(a4,LOW);
   digitalWrite(b1,HIGH);
   digitalWrite(b2,LOW);
   digitalWrite(b3,LOW);
   digitalWrite(b4,LOW);
   //A=0001    B=0001
   delay(100);
   digitalWrite(a1,HIGH);
   digitalWrite(a2,LOW);
   digitalWrite(a3,LOW);
   digitalWrite(a4,LOW);
   digitalWrite(b1,LOW);
   digitalWrite(b2,LOW);
   digitalWrite(b3,LOW);
   digitalWrite(b4,LOW);
   //A=0001   B=0000
   delay(100);
     
   digitalWrite(a1,LOW);
   digitalWrite(a2,LOW);
   digitalWrite(a3,LOW);
   digitalWrite(a4,LOW);
   digitalWrite(b1,HIGH);
   digitalWrite(b2,LOW);
   digitalWrite(b3,LOW);
   digitalWrite(b4,LOW);
   //A=0000    B=0001
   delay(100);
  
   digitalWrite(a1,LOW);
   digitalWrite(a2,LOW);
   digitalWrite(a3,LOW);
   digitalWrite(a4,LOW);
   digitalWrite(b1,LOW);
   digitalWrite(b2,HIGH);
   digitalWrite(b3,LOW);
   digitalWrite(b4,LOW);
   //A=0000   B=0010
   delay(100);
  
   digitalWrite(a1,HIGH);
   digitalWrite(a2,HIGH);
   digitalWrite(a3,LOW);
   digitalWrite(a4,LOW);
   digitalWrite(b1,LOW);
   digitalWrite(b2,LOW);
   digitalWrite(b3,LOW);
   digitalWrite(b4,LOW);
   //A=0011   B=0000
   delay(100);
  
   digitalWrite(a1,HIGH);
   digitalWrite(a2,LOW);
   digitalWrite(a3,LOW);
   digitalWrite(a4,LOW);
   digitalWrite(b1,HIGH);
   digitalWrite(b2,HIGH);
   digitalWrite(b3,LOW);
   digitalWrite(b4,LOW);
   //A=0001    B=0011
   delay(100);
  
   digitalWrite(a1,HIGH);
   digitalWrite(a2,LOW);
   digitalWrite(a3,LOW);
   digitalWrite(a4,LOW);
   digitalWrite(b1,HIGH);
   digitalWrite(b2,HIGH);
   digitalWrite(b3,HIGH);
   digitalWrite(b4,LOW);
   //A=0001   B=0111
   delay(100);
  
   digitalWrite(a1,LOW);
   digitalWrite(a2,LOW);
   digitalWrite(a3,LOW);
   digitalWrite(a4,LOW);
   digitalWrite(b1,LOW);
   digitalWrite(b2,LOW);
   digitalWrite(b3,LOW);
   digitalWrite(b4,LOW);
   //A=0000   B=0000
   delay(1000);
  
 }



Conclusión

Mi conclusión es que este circuito serviría mucho en varios casos al momento de armar una maquina en la industria ya que puede decidir cuál es mayor o menor y ayudaría a facilitar el trabajo, además te ayudaría a ahorrar componentes utilizando este circuito integrado. 


miércoles, 22 de julio de 2015

Multiplexor y Demultiplexor


Un multiplexor o demultiplexor le permite ampliar la de entrada y salidas en su placa Arduino. El 4051 es de 8 canales analógicos ya sea multiplexor o demultiplexor.
Si utiliza el 4051 como un multiplexor, se puede elegir entre 8 entradas diferentes y seleccionar que solo una se lea en el momento.
Si utiliza el 4051 como un demultiplexor se puede elegir una entreda y tener 8 salidas en las que se desea escribir en el momento.














Multiplexor analógico / demultiplexor - 4051













Un multiplexor o demultiplexor le permite ampliar la de entrada y salidas en su placa Arduino.
El 4051 es de8 canales analógicos multiplexor / demultiplexor.
Ø  Si utiliza el 4051 como un multiplexor: Se puede elegir entre 8 entradas diferentes y seleccionar sólo uno desea leer en el momento.
Ø  Si utiliza el 4051 como un demultiplexor se puede escribir pulsos en una sola entrada y tendra 8 salidas para leer.
Circuito integrado, el 4051 es capaz de trabajar con valores analógicos; en el caso de la Arduino, que son capaces de utilizar las entradas analógicas con una tensión entre 0-5V y encaminarlos a un Analog-In Pin en tu Arduino.



Para seleccionar el Pin en el que vamos a escribir, tenemos que usar los tres Seleccionar Pins (S0, S1 y S2). Cada uno de estos pines tienen que ser conectado a un pasador digital en el Arduino. Cada pin está representando a un número (S0 = 1; S1 = 2; S2 = 4) y si establecemos una de estas Seleccione pines a HIGH, el número del pin está representando será transmitida al 4051. Por ejemplo:

Ø  Si S0 y S1 son HIGH y S2 es y3 pin LOW se selecciona (1 + 2 + 0 = 3).
Ø  Si S0 y S2 es HIGH y se selecciona S1 pin LOW y5 (1 + 0 + 4 = 5).
No es posible leer o escribir más de un pin en el 4051, al mismo tiempo, porque sólo se puede seleccionar un pin a la vez. Pero usted puede leer y escribir a los pines bastante rápido. No hay retraso necesario entre la selección y leer o escribir el pasador.



Z ----- de entrada común / salida (conectado a Arduino de entrada / salida)
E ----- entrada de habilitación (LOW activo) (conectado a tierra (GND))
Vee --- tensión de alimentación negativa (conectado a tierra (GND))
GND --- tierra (0 V)
S0-S2 - entradas de selección (conectado a tres arduino DIGITALOUT Pins)
y0-y7 - entradas / salidas independientes
Vcc --- tensión de alimentación positiva (5v)




Materiales a utilizar:
Ø  2 Circuitos integrados (HCF4051 Multiplexor/Demultiplexor)
Ø  16 led´s
Ø  16 Resistencias de 330 Ω
Ø  1 Protoboard
Ø  1 Arduino

Cuando se necesita multiplexar más de 8 entradas se pueden utilizar dos IC 4051
Por medio de la entrada ENABLE (pin 6 del 4051)
Simultáneamente por medio de las entradas análogas.
En el diagrama se ven los dos multiplexores 4051 conectados a los pines digitales 5,6 y 7 que son los que controlan la cuenta en binario del 0 hasta el 15, cuando la cuenta
Alcanza el 7, el enable ( naranja ) del primer Mux se pone en estado HIGH y el enable del multiplexor 2 (morado) se pone en estado LOW por que trabajan con lógica inversa.
En el diagrama la entrada ( pin 3) de ambos Multiplexores está conectada a 5 volts para que multiplexe
El encendido de los 16 leds, si se necesita multiplexar 16 sensores analogos se conectan esos pines a una entrada análoga de arduino y listo, al armar el circuito cuidado con las salidas de los multiplexores son 4 de cada lado y no están en orden  ( ver alambres gris y cafe)
A continuación el sketch para el control de los 2 multiplexores 4051:



int s0 = 5;  // primer digito binario, verde, pin 11 ambos multiplexores
int s1 = 6;  // segundo digito binario, amarillo, pin 10 ambos multiplexores
int s2 = 7;  // tercer digito binario, azul, pin 9 ambos multiplexores
int m0 = 2;  // enable mux1, pin 6 multiplexor 1
int m1 = 3;  // enable mux2, pata 6 multiplexor 2
int rowTTL = 0;
int binTTL [] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};// digitos de cuenta
int inPin = 0;
int pinled = 8; // pin de salida cuando la lectura analoga este por debajo
//de un rango este pin se pone en HIGH
int result = 0; //declaracion de variable para lectura analoga

void setup(){
pinMode(s0, OUTPUT);
pinMode(s1, OUTPUT);
pinMode(s2, OUTPUT);
pinMode(m0, OUTPUT);
pinMode(m1, OUTPUT);
pinMode(pinled, OUTPUT);
// pinMode(inPin, INPUT);
Serial.begin(9600);
}
void loop(){
for(int i=0; i<16; i++){

result = 0;

rowTTL = binTTL[i];
sendABCTTL(rowTTL);
result = analogRead(inPin);

if(result > 600) { // parte lógica para manipular motores, comentar cuando calibress
Serial.println(0);
digitalWrite (pinled, HIGH);
}
else {
Serial.println(1); // contact!
digitalWrite (pinled, LOW);
}

delay(300);
Serial.print(binTTL[rowTTL]);
Serial.print(”    “);
// Serial.println( result ); // instruccion para calibrar
}
}

void sendABCTTL(int rowTTL){

switch (rowTTL >> 3) {
case 0:
digitalWrite(m0,LOW); // this enables mux 1 HIGH
digitalWrite(m1,HIGH);
break;

case 1:
digitalWrite(m0,HIGH); // this enables mux 2
digitalWrite(m1,LOW);
break;
}

switch(rowTTL & 7)  //transformacion de cuenta en digitos binarios
{
case 0:
digitalWrite(s0, LOW);
digitalWrite(s1, LOW);
digitalWrite(s2, LOW);
break;

case 1:
digitalWrite(s0, HIGH);
digitalWrite(s1, LOW);
digitalWrite(s2, LOW);
break;

case 2:
digitalWrite(s0, LOW);
digitalWrite(s1, HIGH);
digitalWrite(s2, LOW);
break;
case 3:
digitalWrite(s0, HIGH);
digitalWrite(s1, HIGH);
digitalWrite(s2, LOW);
break;
case 4:
digitalWrite(s0, LOW);
digitalWrite(s1, LOW);
digitalWrite(s2, HIGH);
break;
case 5:
digitalWrite(s0, HIGH);
digitalWrite(s1, LOW);
digitalWrite(s2, HIGH);
break;
case 6:
digitalWrite(s0, LOW);
digitalWrite(s1, HIGH);
digitalWrite(s2, HIGH);
break;
case 7:
digitalWrite(s0, HIGH);
digitalWrite(s1, HIGH);
digitalWrite(s2, HIGH);
break;
}
}
Conclusion
Conclusion
Mi conclusión de este componente es que es muy útil porque ya en dado caso hay veces que nos faltan salidas en nuestro Arduino y con este multiplexor y demultiplexor puedes con una sola salida puedes sacar 8 salidas más con el circuito integrado que utilizamos hay muchos más circuitos integrados con más salidas que se usan según los requerimientos del proyecto que vallas construir es un poco difícil solo tienes que poner atención en el diagrama de salidas, entras y saber que compuertas lógicas utiliza.