Practica 8 Cubo de Leds

Introducción

En esta práctica utilizamos el Psoc, para elaborar un cubo de led's con secuencias programadas y un modulo para programar con el teclado matricial.

Materiales

• Protoboard 
• PSoC 5LP
• Cables 
• 27 led's
• 27 resistencias 330 ohm 
• Fuente variable
• Teclado matricial 4 x 4

Desarrollo

El cubo se construyo de 3 x 3 conectando cada columna individualmente obteniendo 9 entradas y conectando las filas en comun obteniendo 3 entradas.

En la primera parte se desarrollo el programa para las secuencias ya predeterminadas, donde se colocaron 8 memorias ROM, conectadas  a unos Buffer y unos mux que nos permiten enviar cada valor a la entrada del cubo.

Las memorias se desarrollaron para una capacidad de 32 secuencias cada una y fueron desarrolladas en verilog, el codigo de una de ella es el siguiente:

//Codigo Memoria Rom Secuencias cubo

module Memoria_cubo_8 (

output reg[11:0] Sal,

input  [4:0] Sel

);

//`#start body` -- edit after this line, do not edit this line

//        Your code goes here

always @(Sel)

begin 

    case(Sel)5'b00000: begin Sal[11:0] = 12'b110000000001; end

5'b00001: begin Sal[11:0] = 12'b110000000010; end

5'b00010: begin Sal[11:0] = 12'b110000000100; end

5'b00011: begin Sal[11:0] = 12'b110000001000; end

5'b00100: begin Sal[11:0] = 12'b110000010000; end

5'b00101: begin Sal[11:0] = 12'b110000100000; end

5'b00110: begin Sal[11:0] = 12'b110001000000; end

5'b00111: begin Sal[11:0] = 12'b110010000000; end

5'b01000: begin Sal[11:0] = 12'b110100000000; end

5'b01001: begin Sal[11:0] = 12'b101000000001; end

5'b01010: begin Sal[11:0] = 12'b101000000010; end

5'b01011: begin Sal[11:0] = 12'b101000000100; end

5'b01100: begin Sal[11:0] = 12'b101000001000; end

5'b01101: begin Sal[11:0] = 12'b101000010000; end

5'b01110: begin Sal[11:0] = 12'b101000100000; end

5'b01111: begin Sal[11:0] = 12'b101001000000; end

5'b10000: begin Sal[11:0] = 12'b101010000000; end

5'b10001: begin Sal[11:0] = 12'b101100000000; end

5'b10010: begin Sal[11:0] = 12'b011000000001; end

5'b10011: begin Sal[11:0] = 12'b011000000010; end

5'b10100: begin Sal[11:0] = 12'b011000000100; end

5'b10101: begin Sal[11:0] = 12'b011000001000; end

5'b10110: begin Sal[11:0] = 12'b011000010000; end

5'b10111: begin Sal[11:0] = 12'b011000100000; end

5'b11000: begin Sal[11:0] = 12'b011001000000; end

5'b11001: begin Sal[11:0] = 12'b011010000000; end

5'b11010: begin Sal[11:0] = 12'b011100000000; end

5'b11011: begin Sal[11:0] = 12'b110111111111; end

5'b11100: begin Sal[11:0] = 12'b101111111111; end

5'b11101: begin Sal[11:0] = 12'b011111111111; end

5'b11110: begin Sal[11:0] = 12'b111111111111; end

5'b11111: begin Sal[11:0] = 12'b101000010000; end

    endcase

end

//`#end` -- edit above this line, do not edit this line

endmodule

Cada memoria recibe de un contador un valor de 5 bit que ingresa a un case y dependiendo asigna el valor que tenga a la salida de la memoria para ser enviada al cubo de led.

Para prender cada led es necesario que la columna se encuentre en "1" y la fila en "0". El valor de cada secuencia esta codificado de la siguiente manera:

Cada memoria se recorre internamente por el contador de 5 bit y luego recibe otro contador que habilita cual memoria se reproduce.

El circuito de implementación final es el siguiente:

Video funcionamiento 

Cubo programado

CUBO PROGRAMABLE

Ahora hay que crear el módulo para programar el cubo a partir de oprimir unos botones en el teclado matricial.

Lo primero será crear una memoria modificable para que guarde la información proveniente de cada botón.

Para esto se va a usar Flip-Flops tipo D como los usados en la práctica 7, pero aunque se va a usar uno por cada bit, se va a modificar uno a la vez y no todos al tiempo como en la practica 7.

Para esto, es necesaria la ayuda de la función Enabled de cada Flip-Flop.

Memoria de 12 bits

En esta memoria, los Flip-Flop del 0 al 8 manejan la información de cada columna de leds, y los Flip-Flop 9, 10 y 11 manejan la información del piso superior, piso medio y piso inferior respectivamente; y la entrada del bit se conecta tanto a D como a Clock.

La función Enabled que está conectada en todos los Flip-Flops se va a usar para determinar la memoria a grabar, es decir, si de las n memorias, una tiene el enabled en 1, dicha memoria guardará la información proporcionada por el teclado y las demás memorias no modificarán sus estados, si se aplica un uno a otra memoria, esta otra memoria guardará la información y la memoria guardada inicialmente no se modificará.

Para usar el teclado matricial de 4*4 se debe agregar el decodificador de teclado usado en la practica 5 junto con el decodificador de 4 entradas y 16 salidas, de las 16 salidas de dicho decodificador, se van a conectar 12 a la memoria.

Las salidas a conectar son las equivalentes a los botones 1, 2, 3, 4, 5, 6, 7, 8 y 9 para los leds, y *, 0 y # para los pisos superior, medio e inferior respectivamente.

Lo demás es diseñar una forma de seleccionar la memoria que se desea guardar, puede ser con un dip-switch; y por ultimo, es necesario un multiplexor que muestre la información de una memoria a la vez con ayuda de un reloj.

El circuito obtenido se muestra a continuación.

Circuito, cubo led programable.

Para este circuito, cada memoria está guardada dentro de un componente de nombre Rom_X6 y la memoria a grabar es seleccionada con un dip-switch conectado en los selectores.

Siguiendo el mismo proceso se puede grabar muchas más memorias, pero hay que tener especial cuidado con el multiplexor, si se desea cambiar el uso de los dip-switch, se puede, con una puerta AND conectada a los bits que se activan en la salida del decodificador de teclado al presionar la tecla D, controlar un circuito contador que después, gracias al decodificador de 4 entradas y 16 salidas trabajado en la practica 5, permita seleccionar la memoria a grabar.

Proyecto en PSoC Creator para descarga

Proyecto secuencias programadas

https://1drv.ms/u/s!Ah-O_9bsvwlWhLkvbZGIQFxrXGdq1A