Ejercicios resueltos de LOGO

 

Para ver detalles de los problemas , visitar la página  Autómata programable en LOGO

Ejercicio 8.

1. Tenemos una bomba que lleva agua desde el pozo al depósito 1, la llamamos B1
2. La otra bomba lleva agua desde el depósito 1 al 2 y la llamamos B2
3. Los sensores de nivel de agua se llaman s1 y s2 para el depósito bajo y los otros s3 y s4
4. No pueden funcionar las dos bombas a la vez

 

Vamos a hacer las siguientes consideraciones

1º De los sensores que tenemos en los depósitos, vamos a considerar error que el de arriba de agua y el de abajo no, o sea, s1=0  y s2 = 1 ES AVERÍA. En esos casos, la bomba no debe trabajar

2º Las dos bombas no pueden trabajar a la vez. La prioridad es que trabaje la B1 para llenar el depósito de abajo

3º Los sensores de arriba del depósito  tienen dos puntos de trabajo. Al subir el agua se conectan en un punto determinado ( alto ), pero al bajar el agua, no se desconecta en el mismo punto, sino unos centímetros más abajo. Esto evita el arranque y paro continuo de las bombas.

Hacemos la tabla de la verdad de las dos bombas.

Para B1, tenemos que se activa cuando el sensor bajo (s1) está activado y el alto desactivado. Por tanto, las combinaciones son

1º Opción s1s2 = 00

2º Opción s1s2 = 10

Esto no genera la función f(B1) = s1  s2 + s1 s2  = s2

Para la B2, hacemos la tabla de Karnaugh

Tomando el grupo de 4, nos queda que la funcion es

f(B2) = s1 s4

Ahora tenemos la condición de que las dos bombas no pueden estar activas a la vez. De alguna manera, una tiene que anular la otra, o sea, cuando una esté con salida alta, debe desactivar la otra función.

La manera mas sencilla es entrando una entrada a la puerta Y, de forma que si B2=1, ponemos un inversor  para tener el valor 0 y entrarlo a la puerta que controla B1.

Hacemos el esquema con puertas con logic.ly

 

Ejercicio 9 . Control de barreras. Se supone que el acceso es tan estrecho que sólo puede pasar un coche. Al sólo tener dos sensores, no podemos asegurarnos la dirección del coche , si sube o baja, por tanto, estaremos dando al sistema una solución mas básica de las reales. Luego mejoraremos el sistema. Tenemos

1.  Dos motores M1 ( bajo)  y M2 ( motor alto ) ( van a depender de las luces, trabajarán los dos a la vez y la barrera estará subida siempre que haya una luz verde )
2. 2 semáforos con   R1, V1 y A1  Lo mismo para el semáforo de arriba V2, A2, R2.
3. 2 sensores de presencia de vehículos S1 y S2

En el punto 1, ya podemos sacar nuestra tabla de la verdad ya que f (M1) =  f (M2) = V1 + V2

En el punto 2 vamos a desestimar la luz ámbar. ¿ Porqué ?. NO se ajusta a un estado de seguridad. Tiene sentido en un paso de cebra, pero no en una rampa, porque dos coches jamás deberían estar en ella, a no ser que vayan en el mismo sentido

En el punto 3 tenemos las entradas. De ellas va a depender todo, salvo que quien manda es S1. Además, tenemos que establecer un sistema de tiempos, por el cual, cuando se establece determinada situación, permanecerá así durante el tiempo necesario para que un coche pueda subir la rampa.

Las luces verdes se encienden para dar paso inicial. Luego se apagan

Además , las rojas se activan en Te. Siempre que esté este tiempo, no se permite que circule coches. Te es un tiempo de seguridad para evitar que se crucen coches.

¿ Cuando se enciende V1 y V2 ?

Damos paso desde abajo a arriba cuando el sistema no está en tiempo de espera( Te), durante el cual se supone que hay un coche circulando por la rampa

Tenemos entonces que f (v1 )= S1 * Te

Ahora tenemos el condicionante de que el coche de abajo tiene prioridad, por tanto para la otra función tenemos f(v2) = S2 * Te *   S1

Esto es, se enciende la verde de arriba si se detecta coche, el tiempo de espera ha terminado y no se detecta coche abajo.

¿ Cuando se enciende R1 y R2 ?

las luces rojas se activan cuando están las verdes mas cuando estamos en el tiempo de espera.

f( R1) = f(v2) + Te   y

f( R2) = f(v1) + Te

Los motores está activos siempre que haya una lámpara verde activa o estemos en el tiempo de espera

f(M1) = f(M2) = f(v1) + f(v2) + Te

El circuito ( que hay que mejorar ) es el siguiente

En esta solución tenemos que desarrollar los bloques de temporizadores para que Te funcione sólo. Pasamos a Logosoft   nuestro proyecto . Antes que nada veremos el bloque de Relé de barrido disparado por flancos.

 

Descripción de la función:

El paso de 0 a  1 en la salida Q se inicia una vez que aparece la entrada  Trg ( disparo ) y pasa un tiempo asignado   en la entrada T_L (time low).

En ese momento,  se pone la salida Q a 1 durante el tiempo T_H (time high), que en nuestro caso lo hemos puesto a 10 segundos ( ver imagen)

Si aparece de nuevo una entrada Trg antes de finalizar el  tiempo total (T_L + T_H),  el bloque  se reinicia

La solución, a falta de algunas mejoras es:

 

Ejercicio 13: 

 Resolvemos el problema del  sistema clave-temporal,  que activa un abrepuertas de una caja fuerte si la secuencia es correcta, en este caso el 1 1 0 1.

Tenemos una sóla entrada A, y dos relojes, uno para la secuencia general y otro para el tiempo total.

Si pasado el tiempo total, la clave no es correcta, se activa la alarma.

Para resolverlo lo vamos, vamos a utilizar el jk que viene dentro de logic.ly utilizando la entrada CLR. Además vamos a crear lo que denominamos célula de memoria. Pasamos a resolverlo.

NO vamos a resolver usando los diagramas de transición porque es bastante laborioso y más si la secuencia de bits de entradas es larga.

1º Lo primero es crear la célula de memoria, por la cual, una vez que llega el pulso de reloj, vamos a almacenar el valor que entra ( A). Hay que tener en cuenta que la entrada CLR debe estar a 1 y que al entrar un 0, el JK se pone a 0, independientemente de las entradas ( por eso lo de CLR = Clear ).

Esta célula va a guardar el 1 de forma permanente cuando la entrada es la adecuada ( 0 o 1 ).

Como tenemos 4 bits, haremos 4 bloques que van a guardar esos datos. Una vez que se termina el tiempo total, se tomarán esos datos a ver si todos están bien. Por tanto, el primer bloque es para el primer bit ( 1 ), el segundo también, el tercero para un 0 y el cuarto de nuevo para 1. Se necesitan tres células que se activen con 1 y una para el 0.

 

Primero hacemos la tabla de forma que una vez que entre el 1, se guarda de forma permanente.

 

A	Q	Q (t+1 )	J	K
0	0	0	0	0
0	1	1	0	0
1	0	1	1	x
1	1	1	0	0

De la tabla sacamos que:

 J = aq y K = 0

La célula JK para 1 la mostramos en la siguiente imagen

Ahora diseñamos otra célula para 0, de forma que , una vez que se detecte el 0 en la entrada, queda grabado de forma permanente.

 

 

A	Q	Q (t+1 )	J	K
0	0	1	1	x
0	1	1	0	0
1	0	0	0	0
1	1	1	0	0

De la tabla sacamos que:

 J = a   q      y  K = 0

Ya tenemos los bloques básicos.

¿ Pero si tenemos sólo una entrada, como evitamos que los bloques se activen en tiempos inapropiados ?. ¿ Cómo evitamos que el bloque dos que se activa con un 1, se active al mismo tiempo que el bloque 1, que también se activa con 1 ?

Para resolver esto, vamos a usar nuestra entrada CLR

Vamos a poner un interruptor que active el CLR de la primera célula. La segunda se va a activar siempre que la salida de la primera célula lo active. La 3º célula funciona si la segunda le da permiso, y así una detrás de otra.

Comprobar que al tener el CLR a 0, el JK no funciona y siempre tenemos la salida a 0, independientemente de los valores de JK

Una vez que hacemos esto y consideranto 4 pulsos de reloj para los 4 valores, las salidas de los 4 JK seran las entradas de una puerta AND que activará el abrepuertas de la caja.

Hemos añadido otras entradas para el  segundo reloj de los 4 pulsos y para el interruptor de CLR.

El siguiente paso es mejorar el circuito ( quizás haya algunas cosas que sobren ) y llevarlo a nuestro programador LOGSOFT. Quedo imagen y circuito completo de la alarma secuencial en logic.ly

A la hora de pasarlo a LOGOSOFT, nos encontramos con ejecuciones no sintonizadas dentro de las puertas ( problemas en simulación ), y por otro lado, tenemos que funciona bien en logic.ly pero llevarlo a LOGOSOFT implica la aparición de errores.

Para solucionarlo, incorporamos las entradas Clear a las puertas, desarrollando un JK de la siguiente manera. Podéis abrir la imagen en un navegador para verla mas grande

Hay un relé con retado para impedir que la segunda salida se active en el primer ciclo de reloj.

El B025 está a 20 segundo. Si no se acierta la clave, sonará la alarma

Podemos descargar  en los siguientes enlaces los archivos de LOGOSOFT de

Biestable JK con entrada Clear

Alarma temporal con clave usando JK