PROYECTO FINAL Sistemas

ELEVADOR Digitales 2

Kevin Flores Abarca

Karen Elifelet Luna Mayer
Jesús Bahena Guadarrama
Introducción
Jesús Bahena Guadarrama:
El proyecto final es aplicar los conocimientos, teóricos y prácticos para la creación de un
elevador de 3 o 4 pisos, el cual funcione tal como se espera que funcione un elevador. Los
conocimientos requeridos para esta práctica son acerca de las máquinas de Mealy, algebra
booleana, Arduino para la operación de motores.

Karen Elifelet Luna Mayer:

En este proyecto tenemos como reto hacer el diagrama de estados donde de manera
correcta haga la simulación de los números en binario que simularán los pisos del edificio
donde estará subiendo o bajando respectivamente el elevador. De manera sencill podemos
controlar en base a 0 y 1 el siguiente número de piso que queramos, 1, 2, 3 o 4. Al igual que
la incorporación del sistema un sensor de proximidad para medir las distancias a las que se
encuentra respecto al techo los pisos y mandar estos datos al Arduino para decirle que tal
piso corresponde x centímetros de distancia del sensor de proximidad.
Kevin Flores Abarca:

Una Máquina de Moore, es un autómata de estados finitos para el cual la salida en un

momento dado solo depende de su estado en ese momento, mientras la transición al
siguiente estado depende del estado en que se encuentre y de la entrada introducida. El
diagrama de estados para una máquina Moore incluirá una señal de salida para cada estado.
Comparada con la Máquina de Mealy, la cual mapea transiciones en la máquina a salidas.
Para esta máquina utilizamos el Flip-Flop JK:

El Flip Flop tiene el carácter de seguimiento de entrada del flip-flop D sincronizado, pero
tiene dos entradas, denominadas tradicionalmente J y K. Si J y K son diferentes, la salida Q
toma el valor de J durante la subida del siguiente pulso de sincronismo.

Si J y K son ambos low (bajo), entonces no se produce cambio alguno. Si J y K son ambos
high (alto), entonces en la siguiente subida de clock la salida cambiará de estado. Puede
realizar las funciones del flip-flop set/reset y tiene la ventaja de que no hay estados
ambiguos. Puede actuar también como un flip-flop T para conseguir la acción de
permutación en la salida, si se conectan entre sí las entradas J y K. Esta aplicación de
permutar el estado, encuentra un uso extensivo en los contadores binarios.

El flip-flop JK tiene un inconveniente de problema de tiempo conocido como "CARRERA".

La condición de RACE surge si la salida Qcambia su estado antes de que el impulso de
temporización de la entrada del reloj tenga tiempo de pasar al estado OFF. El período de
pulso de tiempo (T) se debe mantener lo más corto posible para evitar el problema de
tiempo.
Máquina de Mealy
Se le denomina así a un circuito secuencial en los que las salidas dependen de sus entradas,
así como el estado en el que se encuentre el FLIP-FLOP.

Para poder entender mejor una máquina de Mealy es necesario comprender ciertos
conceptos acerca de los circuitos secuenciales, tal como lo es la tabla de estados, la cual nos
permitirá interpretar cuales serían las salidas en base a la entrada y los estados anteriores,
por lo tanto, debería de lucir de la siguiente manera e incluir las siguientes variables.

Una vez teniendo una tabla de estados es posible determinar cuál sería el circuito que se
tendría que armar, esto obteniendo la expresión de la salida o salidas según sea el caso. La
información obtenida en la tabla previamente mostrada se puede representar de una
manera grafica en un diagrama de estados, en este diagrama cada posible estado es
representado por un círculo y las líneas que conectan a los círculos es el estado de la entrada
que se necesita para que cambie a dicho estado. el diagrama de estados muestra
exactamente la misma información que la tabla de la verdad, un diagrama de estados
estaría representado de la siguiente manera.
En base a esta imagen se interpreta que de acuerdo con dos entradas y sus estados actuales
cambiaran a otro estado en caso de cumplirse las condiciones.

¿Qué armaremos esta ocasión?

Realizar un elevador de 3 a 4 pisos empleando los conocimientos adquiridos durante el
curso.

Partiendo de la propuesta del proyecto surgieron distintas maneras de armar el circuito, la

mostrada a continuación en base al diagrama de estados fue considerada como la mejor
opción. Siendo que los numeros que no se muestran en binario, es el numero de
pisos.
00

A 0

1,2,3 01

D B
11
3 0,1
2,1,0 2,3
C
10

A B
A=0 0 0
 B=1 0 1
C=2 1 0
D=3 1 1
Por lo tanto, partiendo del diagrama podemos llegar a la tabla de estados, la cual quedaría
de la siguiente forma Estado
Actual Qt+1
A B X Y A B
0 0 0 0 0 0 A
0 0 0 1 0 1 B
0 0 1 0 0 1 B
0 1 1 1 0 1 B
0 1 0 0 0 0 A
0 1 0 1 0 1 B
0 1 1 0 1 0 C
0 1 1 1 1 0 C
1 0 0 0 0 1 B
1 0 0 1 0 1 B
1 0 1 0 1 0 C
1 0 1 1 1 1 D
1 1 0 0 1 0 C
1 1 0 1 1 0 C
1 1 1 0 1 0 C
1 1 1 1 1 0 D
Debe de entenderse que dependiendo cual sea el estado de los Flip Flops será la salida que
se deberá esperar, teniendo en cuenta que X y Y son las entradas cuales permitirán
determinar el estado de salida.
Lista de materiales
A continuación, se mostrará el listado de los materiales empleados en la práctica:

NE 555 Circuito integrado XOR Flip Flop 7473

Multímetro Protoboard (3) LED

Potenciómetro de 250kOHM Caimanes NOT (7404)

Resistencia 10k OHM Capacitor 4.7μF Capacitor 0.1μF

Resistencia 220 OHM AND 7408 OR 7432

Decodificador 7448 Display de 7 segmentos motor reductor

Caja de cartón Arduino
Diagrama y desarrollo
El circuito propuesto fue simulado y armado de la siguiente forma

Nuestra combinación de compuertas lógicas nos mandaran la información en números

binarios a los Flip Flops que entregaran las señales para el decodificador que nos convertirá
de estado binario a decimal. las señales de reloj mediante el pulsador 555 nos ayudara a
hacer los cambios mediante la velocidad que le demos. El control de los motores es gracias
a una programación en Arduino que en pocas palabras el motor se meneara dependiendo
3 variables, las 2 entradas que le damos de lectura a los circuitos combinacionales (entradas
de los números binarios) y la tercera dependerá de la distancia que lea el ultrasónico (que
nos indica donde se encuentra el elevador)

Cuando X = 0 Y=0
Como se puede ver tanto en la simulación como en el circuito físico cuando ambas entradas
sean 0 el elevador bajará a la planta baja, sea cual sea el piso en el que este se encuentre,
siendo el estado inicial de nuestro circuito, en el código de Arduino estará condicionado que
si se encuentra en cualquier piso se accione el motor.

Cuando X = 0 Y=1
Como se puede ver tanto en la simulación como en el circuito físico cuando X=0 Y=1 el
elevador subirá o bajará (dependiendo en la plata que se encuentre) a la planta 1, el
accionamiento del motor se hará por un tiempo.

Cuando X = 1 Y=0
Como se puede ver tanto en la simulación como en el circuito físico cuando X=1 Y=0 el
elevador subirá o bajará (dependiendo en la plata que se encuentre) a la planta 2, el
accionamiento del motor se hará por un tiempo.

Cuando X = 1 Y=1
Como se puede ver tanto en la simulación como en el circuito físico cuando X=1 Y=1 el
elevador subirá a la planta 3, el accionamiento del motor se hará por un tiempo.
Código generado en Arduino
El código generado única y exclusivamente para el motor, fue el siguiente:

// lectura de datos
int lectura = 0;
int lectura2 = 0;

// ultrasonico
int pintrig = 8;
int pinecho = 7;
int pintiempo;
int distancia;

// puente H
int velocidad = 11;
int dpin1 = 12;
int dpin2 = 13;
int v = 225;

int EstadoElevador;

void setup() {
// lectura de datos
pinMode(6, INPUT);
pinMode(5, INPUT);
Serial.begin(9600);

// ultrasonico
pinMode(pintrig, OUTPUT);
pinMode(pinecho, INPUT);
 digitalWrite(pintrig, LOW);

// puente H
pinMode(velocidad, OUTPUT);
pinMode(dpin1, OUTPUT);
pinMode(dpin2, OUTPUT);

EstadoElevador = 0;
}

void loop() {

ultrasonico();
lecturad();

if (distancia <= 40 && EstadoElevador == 0) //esta en primer piso

{

if (lectura == 0 && lectura2 == 0) //quiere ir a primer piso

{
detener();

}
if (lectura == 0 && lectura2 == 1) //quiere ir a segundo piso
{
arriba();
delay(2000);
detener();
EstadoElevador = 1;
 }
if (lectura == 1 && lectura2 == 0) //quiere ir a tercer piso
{

arriba();
delay(3500);
detener();
EstadoElevador = 2;
}
if (lectura == 1 && lectura2 == 1) //quiere ir a cuarto piso
{
arriba();
delay(3500);
detener();
EstadoElevador = 3;

if (distancia <= 28 && EstadoElevador == 1) //esta en segundo piso

{

if (lectura == 0 && lectura2 == 0) //quiere ir a primer piso

{
abajo();
delay(2000);
detener();
EstadoElevador = 0;
 }
if (lectura == 0 && lectura2 == 1) //quiere ir a segundo piso
{
detener();
}
if (lectura == 1 && lectura2 == 0) //quiere ir a tercer piso
{

arriba();
delay(4500);
detener();
EstadoElevador = 2;
}
if (lectura == 1 && lectura2 == 1) //quiere ir a cuarto piso
{
arriba();
delay(2600);
detener();
EstadoElevador = 3;

if (distancia <= 18 && EstadoElevador == 2) //esta en tercer piso

{

if (lectura == 0 && lectura2 == 0 ) //quiere ir a primer piso

{
 abajo();
delay(3300);
detener();
EstadoElevador = 0;
}
if (lectura == 0 && lectura2 == 1) //quiere ir a segundo piso
{
abajo();
delay(1800);
detener();
EstadoElevador = 1;
}
if (lectura == 1 && lectura2 == 0) //quiere ir a tercer piso
{
detener();
}
if (lectura == 1 && lectura2 == 1) //quiere ir a cuarto piso
{
arriba();
delay(1900);
detener();
EstadoElevador = 3;

if (distancia <= 8 && EstadoElevador == 3) //esta en cuarto piso

{
 if (lectura == 0 && lectura2 == 0) //quiere ir a primer piso
{
abajo();
delay(2500);
detener();
EstadoElevador = 0;
}
if (lectura == 0 && lectura2 == 1) //quiere ir a segundo piso
{
abajo();
delay(2500);
detener();
EstadoElevador = 1;
}
if (lectura == 1 && lectura2 == 0) //quiere ir a tercer piso
{
abajo();
delay(1200);
detener();
EstadoElevador = 2;
}
if (lectura == 1 && lectura2 == 1) //quiere ir a cuarto piso
{
detener();

}
}

void arriba()
{
digitalWrite(dpin1, 0);
digitalWrite(dpin2, 1);
analogWrite(velocidad, v);

}
void abajo()
{
digitalWrite(dpin1, 1);
digitalWrite(dpin2, 0);
analogWrite(velocidad, v);
}

void lecturad() //lectura de datos

{
lectura = digitalRead(5);
lectura2 = digitalRead(6); //lee y guarda el valor
delay(500);
Serial.print("pin1: " );//lectura para pin 1
Serial.print(lectura);
Serial.println("");
Serial.print("pin2: " );//lectura para pin 2
Serial.println(lectura2);
}
 void ultrasonico()
{
digitalWrite(pintrig, HIGH);
delayMicroseconds(10);
digitalWrite(pintrig, LOW);
pintiempo = pulseIn(pinecho, HIGH);
distancia = pintiempo / 59;

Serial.print("distancia ");
Serial.print(distancia);
Serial.println(" cm");
delay(1000);
}

void detener()

{
digitalWrite(dpin1, LOW);
digitalWrite(dpin2, LOW);
}

Video del funcionamiento

 https://youtu.be/o-eIEc4TIRo
Conclusión
Kevin Flores Abarca

Nuestra máquina de Estados fue diseñada con Flip-Flop JK ya que es un circuito que necesita
ser activado por dos variables así que en este caso el Flip-Flop D no nos serviría ya que el
solo es utilizado para depender de una variable. Para que mi circuito sea más viable
utilizamos el JK ya q podemos ahorrar en costos y tamaño de circuito.
El funcionamiento de nuestro elevador es mediante nuestra combinación de circuitos
combinacionales ya que dependiendo de ellos le dará la señal al Flip- Flop y ya el mandará
valores que nos indicaran a qué posición irá nuestro elevador. El control de nuestro motor
(para mandar a nuestro elevador a la posición deseada) depende de una programación que
fue creada dependiente de 2 sentencias:
1. Lugar donde se encuentre mi elevador (mediante un sensor ultrasónico mediremos la
distancia y con ello saber en qué piso está mi elevador) está será mi variable por la cual
dependerá la segunda sentencia
2. Valores que del usuario al subir al elevador (para nosotros serán dos variables que serán
el número del piso que quiera ir de forma binaria) 00=0, 01=1, 10=2, 11=3
Al saber en qué lugar se encuentra nuestro elevador (con el sensor ultrasónico) la segunda
cuestión será a que piso quiere ir el usuario así que con mis dos variables ya podré saber
dónde está y a dónde quiero ir así que solo será cuestión de darle una orden a mi motor de
que tiempo se debe mover
Jesús Bahena Guadarrama
El proyecto nos permitió poner en practica nuestros conocimientos adquiridos a lo largo del
semestre, el elevador presento un reto ya que el primer día que se propuso el ejercicio
apareció una propuesta la cual resultaba ser algo que realmente no exigía un circuito para
nada complicado, lo que resulto en buscar métodos que resultaran de una mejor manera.
Karen Elifelet Luna Mayer
Fue un proyecto complicado principalmente a la parte física, ya que es una variable que
quizá no consideramos tan complicada como la programación o lógica del diseño del
circuito, sin embargo, si la variable de diseño es errónea nos provoca más problemas como
lo es la caja donde no está correctamente situada, el elevador que puede ser muy pesado
o balancearse, el hilo que lo sube es muy pesado o se atora con facilidad, etc. Aun así, se
concluyó de manera exitosa el proyecto tanto en la programación como en lo físico.
Bibliografía

 Mano, M. Morris; Kime, Charles (2005) Fundamentos de diseño lógico y de

computadoras, Pearson Educación. Madrid.

 Orozco, J. A. G., & de Cómputo, E. S. Máquinas de Estados Finitos.