Laboratorio # 5

Descripción:

Este laboratorio consiste en recibir un valor convertido de un potenciometro conectado a la entrada análoga A0 del arduino, esta señal debe ser tratada con una función para determinar el intervalo del valor de 0 a 9 para asi mostrarlo en un display 7-segmentos conectados a la salida del integrado en este caso el IC 74HC595.

Mediante un array de datos de tipo byte se manejan los patrones a mostrar en el dislay. Los datos estan escritos en binario.

0b00111111 = 0

0b00000110 = 1

0b01011011 = 2

0b01001111 = 3

0b01100110 = 4

0b01101101 = 5

0b01111101 = 6

0b00000111 = 7

0b01111111 = 8

0b01101111 = 9

Para el enviar los patrones al display el integrado hace una conversión serial paralelo para reducir el numero de pines necesarios para mostrar el numero de 7 pines a 3 pines solamente (Data, Latch, Clock).

Materiales:

• Arduino UNO
• Circuito integrado IC 74HC595
• Display 7-Segmentos cátodo común
• 7 Resistencias
• Computador con su respectivo programa de desarrollo arduino
• Protoboard
• Cables

Diagramas: 

Montaje

Esquemático 

Código

1. //*----------------------
2. // Laboratorio #5
3. // Programa Arduino
4. // Display 7 segmentos conectado a Arduino por medio de un
5. // Registro de desplazamiento IC 74HC595 recibiendo datos
6. // seriales y enviado el mismo dato en paralelo.
7. // Johnson Camilo Barona Sanchez
8. //*----------------------
9.  
10. #define MAX 10
11. // se inicializan los pines para en envio de los datos al integrado
12. int latchPin = 8;
13. int clockPin = 12;
14. int dataPin = 11;
15. // se inicializan los arreglos para cada patrón
16. byte Num[10];
17. // otras variables usadas
18. int pin;
19. int valor;
20. int pot = A0;
21.  
22. // config del programa
23. void setup() {
24.  
25.   // se configuran los pines como salidas y el modulo de com serial
26.   pinMode(latchPin, OUTPUT);
27.   pinMode(dataPin, OUTPUT);  
28.   pinMode(clockPin, OUTPUT);
29.   pinMode(pot, INPUT);
30.  
31.   // se guarda cada patron de bits dependiendo del numero
32.   // que se va a visualizar
33.   Num[0]= 0b00111111;    // o 0x3F o 63
34.   Num[1]= 0b00000110;    // o 0x06 o 6
35.   Num[2]= 0b01011011;    // o 0x5B o 91
36.   Num[3]= 0b01001111;    // o 0x0F o 79
37.   Num[4]= 0b01100110;    // o 0x66 o 102
38.   Num[5]= 0b01101101;    // o 0x6D o 109
39.   Num[6]= 0b01111101;    // o 0x7D o 125
40.   Num[7]= 0b00000111;    // o 0x07 o 7
41.   Num[8]= 0b01111111;    // o 0x7F o 127
42.   Num[9]= 0b01101111;    // o 0x6F o 111
43. }
44.  
45. // Bucle de ejecución del programa
46. void loop() {
47.   // se lee el dato analogo
48.   valor = analogRead(pot);
49.   // la funcion separa el valor recibido en rangos de datos
50.   // y se guarda el rango correspondiente en un integer
51.   int pin = map(valor, 0,1023,0,9);
52.   // se condiciona la ejecucion del comando envio
53.   // de acuerdo al rango detectado
54.   if (pin == 0){
55.     envio(Num[0]);
56.   }
57.   if (pin == 1){
58.     envio(Num[1]);
59.   }
60.   if (pin == 2){
61.     envio(Num[2]);
62.   }
63.   if (pin == 3){
64.     envio(Num[3]);
65.   }
66.   if (pin == 4){
67.     envio(Num[4]);
68.   }
69.   if (pin == 5){
70.     envio(Num[5]);
71.   }
72.   if (pin == 6){
73.     envio(Num[6]);
74.   }
75.   if (pin == 7){
76.     envio(Num[7]);
77.   }
78.   if (pin == 8){
79.     envio(Num[8]);
80.   }
81.   if (pin == 9){
82.     envio(Num[9]);
83.   }
84. }
85.  
86. // la funcion envio selecciona el byte correcto y lo envia al integrado
87.  
88. void envio(byte A){
89.  
90.   // se pone el pin latch en cero para guardar el valor mientras se transmite.
91.   digitalWrite(latchPin, 0);
92.   // se envia el dato  
93.   shiftOut(dataPin, clockPin, MSBFIRST, A);
94.   // se regresa el pin latch a estado alto para esperar el nuevo valor
95.   digitalWrite(latchPin, 1);
96.   delay(100);
97. }

Proceso de Montaje

Display 7-Segmentos

Integrado IC 74HC595

Procedemos a montar en la protoboard el display 7-segmentos con sus respectivas resistencias de protección y luego estas al negativo del arduino. 

Luego Procedemos a conectar el integrado con las conexiones indicadas en su datasheet.

Finalmente cuando todas las conexiones eléctricas están listas, procedemos a programar y luego enviar el código ya apreciado anteriormente a nuestro circuito para su funcionamiento.

Laboratorio # 4

Descripción:

En este laboratorio enviaremos 8 patrones de encendido diferentes vía serial desde el programa Processing al Arduino y dar muestra a través de 8 LEDs que están conectados al integrado IC 74HC595 que es un registro de desplazamiento el cual podemos utilizarlo como un puerto de 8 salidas con una entrada de datos y dos auxiliares.

Materiales: 

• Arduino UNO
• Circuito integrado IC74HC595
• 8 LEDs
• 8 Resistencias
• Protoboard
• Computador con respectivo programa de desarrollo Arduino y Processing
• Cables

Diagramas:

Montaje

Esquemático

Código

Arduino

1. //*----------------------
2. // Laboratorio #4
3. // Programa Arduino
4. // interfaz gráfica selección de 8 patrones de luz
5. // usando 8 Leds y registro de desplazamiento IC 74HC595
6. // Johnson Camilo Barona Sanchez
7. //*----------------------
8.  
9. // se inicializan los pines para en envio de los datos
10. // al integrado
11. int latchPin = 8;
12. int clockPin = 12;
13. int dataPin = 11;
14.  
15. // se inicializan los arreglos para cada patrón
16. int dato;
17. int P_A[17] = {0, 1, 3, 7, 15, 31, 63, 127, 255, 127, 63, 31, 15, 7, 3, 1, 0};
18. int P_B[16] = {0, 2, 4, 8, 16, 32, 64, 128, 64, 32, 16, 8, 4, 2, 1, 0};
19. int P_C[9] = {0, 129, 66, 36, 24, 36, 66, 129, 0 };
20. int P_D[10] = {0, 1, 5, 21, 85, 213, 245, 253, 255, 0};
21. int P_E[7] = {0, 255, 189, 165, 161, 129, 0};
22. int P_F[13] = {0, 1, 129, 131, 195, 199, 231, 239, 255, 231, 195, 129, 0};
23. int P_G[9] = {0, 3, 15, 63, 255, 243, 240, 192, 0};
24. int P_H[9] = {0, 240, 255, 15, 255, 15, 255, 240, 0 };
25.  
26. // variable para la lectura del dato serial desde processing
27. char Letra;
28.  
29. // config del programa
30. void setup() {
31.  
32.   // se configuran los pines como salidas y el modulo de com serial
33.   pinMode(latchPin, OUTPUT);
34.   pinMode(dataPin, OUTPUT);  
35.   pinMode(clockPin, OUTPUT);
36.   Serial.begin(9600);
37.  
38. }
39.  
40. // Bucle de ejecución del programa
41. void loop() {
42.  
43.   // Si hay datos disponibles en el puerto serial
44.   if (Serial.available() > 0)
45.   {  
46.     // Leer la letra actual en el buffer
47.     Letra = Serial.read();
48.    
49.     // aqui se condiciona si la letra enviada está entre las
50.     // opciones y ejecuta el patron determinado
51.    
52.     if (Letra == 'A'){
53.       Patron_A();
54.     }
55.     if (Letra == 'B'){
56.       Patron_B();
57.     }
58.     if (Letra == 'C'){
59.       Patron_C();
60.     }
61.     if (Letra == 'D'){
62.       Patron_D();
63.     }
64.     if (Letra == 'E'){
65.       Patron_E();
66.     }
67.     if (Letra == 'F'){
68.       Patron_F();
69.     }
70.     if (Letra == 'G'){
71.       Patron_G();
72.     }
73.     if (Letra == 'H'){
74.       Patron_H();
75.     }
76.    
77.     // el bucle se ejecuta mientras hayan datos disponibles
78.     // por leer en el buffer.
79.    
80.   }
81. }
82.  
83. // a continuacion y hasta el final de codigo estan las funciones
84. // para mostrar los patrones en cada caso descrito arriba.
85.  
86. void Patron_A(){
87.  
88.   for (int j = 0; j < 17; j++) {
89.     // carga la secuencia del arreglo determinado.
90.     dato = P_A[j];
91.     // funcion de envio
92.     envio();
93.     delay(100);
94.   }
95. }  
96.  
97. void Patron_B(){
98.  
99.   for (int j = 0; j < 16; j++) {
100.     // carga la secuencia del arreglo determinado
101.     dato = P_B[j];
102.     envio();
103.     delay(100);
104.     }
105. }  
106.  
107.  
108.  
109. void Patron_C(){
110.  
111.   for (int j = 0; j < 9; j++) {
112.     // carga la secuencia del arreglo determinado
113.     dato = P_C[j];
114.     envio();
115.     delay(200);
116.     }
117. }
118.  
119. void Patron_D(){
120.  
121.   for (int j = 0; j < 10; j++) {
122.     // carga la secuencia del arreglo determinado
123.     dato = P_D[j];
124.     envio();
125.     delay(200);
126.     }
127. }
128.  
129. void Patron_E(){
130.  
131.   for (int j = 0; j < 7; j++) {
132.     // carga la secuencia del arreglo determinado
133.     dato = P_E[j];
134.     envio();
135.     delay(200);
136.     }
137. }
138.  
139. void Patron_F(){
140.  
141.   for (int j = 0; j < 13; j++) {
142.     // carga la secuencia del arreglo determinado
143.     dato = P_F[j];
144.     envio();
145.     delay(100);
146.    
147.   }
148. }  
149.  
150. void Patron_G(){
151.  
152.   for (int j = 0; j < 9; j++) {
153.     // carga la secuencia del arreglo determinado
154.     dato = P_G[j];
155.     envio();
156.     delay(300);
157.    
158.   }
159. }  
160.  
161. void Patron_H(){
162.   for (int j = 0; j < 9; j++) {
163.     dato = P_H[j];
164.     envio();
165.     delay(300);
166.   }
167. }
168.  
169. void envio(){
170.     // se pone el pin latch en cero para guardar el valor mientras se transmite.
171.     digitalWrite(latchPin, 0);
172.     //
173.     shiftOut(dataPin, clockPin, MSBFIRST, dato);
174.     // se regresa el pin latch a estado alto para esperar el nuevo valor
175.     digitalWrite(latchPin, 1);
176. }

Processing

1. //*----------------------
2. // Laboratorio #4
3. // Programa Processing
4. // interfaz grafica seleccion de 8 patrones de luz
5. // usando 8 Leds y registro de desplazamiento IC 74HC595
6. // Johnson Camilo Barona Sanchez
7. //*----------------------
8.  
9. import controlP5.*;
10. import processing.serial.*;
11.  
12. // se definen los objetos usados
13. ControlP5 cp5;
14. Serial serial;
15.  
16. // variables
17. int myColor = color(255);
18. int c1, c2;
19. String letra;
20. int [] Clr = {
21.   255, 255, 255
22. };
23. float n, n1;
24.  
25. // Solo se ejecuta una vez, al iniciar el Sketch
26. void setup() {
27.  
28.   size(200, 350); // tamaño de la ventana
29.   noStroke();    // no dibujar el border de los rectángulos
30.  
31.   // crear el objeto ControlP5 y cada boton
32.   cp5 = new ControlP5(this);
33.  
34.   cp5.addButton("MovA")
35.     .setValue(0)
36.       .setPosition(50, 50)
37.         .setSize(100, 25)
38.           ;
39.  
40.   cp5.addButton("MovB")
41.     .setValue(100)
42.       .setPosition(50, 80)
43.         .setSize(100, 25)
44.           ;
45.  
46.   cp5.addButton("MovC")
47.     .setValue(0)
48.       .setPosition(50, 110)
49.         .setSize(100, 25)
50.           ;
51.  
52.   cp5.addButton("MovD")
53.     .setValue(0)
54.       .setPosition(50, 140)
55.         .setSize(100, 25)
56.           ;
57.  
58.   cp5.addButton("MovE")
59.     .setValue(0)
60.       .setPosition(50, 170)
61.         .setSize(100, 25)
62.           ;  
63.  
64.   cp5.addButton("MovF")
65.     .setValue(0)
66.       .setPosition(50, 200)
67.         .setSize(100, 25)
68.           ;  
69.  
70.   cp5.addButton("MovG")
71.     .setValue(0)
72.       .setPosition(50, 230)
73.         .setSize(100, 25)
74.           ;  
75.  
76.   cp5.addButton("MovH")
77.     .setValue(0)
78.       .setPosition(50, 260)
79.         .setSize(100, 25)
80.           ;      
81.  
82.   // Creamos el objeto del puerto Serial
83.   serial = new Serial(this, Serial.list()[0], 9600);
84. }
85.  
86. void draw() {
87.  
88.   // se dibuja el color de fondo de acuerdo
89.   // al boton pulsado
90.   background(myColor);
91.   myColor = lerpColor(c1, c2, n);
92.   n += (1-n)* 0.05;
93. }
94.  
95. public void controlEvent(ControlEvent evento) {
96.  
97.   // guardar el nombre y valor del evento
98.   n = 0;
99.   String nombre = evento.getController().getName();
100.  
101.   // dependiendo del nombre del evento se carga una letra a
102.   // la variable del mismo nombre y se guarda un color para cada uno
103.  
104.   if (nombre == "MovA") {
105.     letra = "A";
106.     Clr[0] = 200;
107.     Clr[1] = 250;
108.     Clr[2] = 255;
109.   }
110.  
111.   if (nombre == "MovB") {
112.     letra = "B";
113.     Clr[0] = 21;
114.     Clr[1] = 156;
115.     Clr[2] = 255;
116.   }
117.  
118.   if (nombre == "MovC") {
119.     letra = "C";
120.     Clr[0] = 236;
121.     Clr[1] = 0;
122.     Clr[2] = 21;
123.   }
124.  
125.   if (nombre == "MovD") {
126.     letra = "D";
127.     Clr[0] = 1;
128.     Clr[1] = 56;
129.     Clr[2] = 100;
130.   }
131.  
132.   if (nombre == "MovE") {
133.     letra = "E";
134.     Clr[0] = 100;
135.     Clr[1] = 50;
136.     Clr[2] = 200;
137.   }
138.  
139.   if (nombre == "MovF") {
140.     letra = "F";
141.     Clr[0] = 25;
142.     Clr[1] = 225;
143.     Clr[2] = 150;
144.   }
145.  
146.   if (nombre == "MovG") {
147.     letra = "G";
148.     Clr[0] = 230;
149.     Clr[1] = 200;
150.     Clr[2] = 200;
151.   }
152.  
153.   if (nombre == "MovH") {
154.     letra = "H";
155.     Clr[0] = 100;
156.     Clr[1] = 100;
157.     Clr[2] = 100;
158.   }
159.  
160.   c1 = c2;
161.   c2 = color(Clr[0], Clr[1], Clr[2]);
162.  
163.   println(letra);
164.   serial.write(letra);
165. }

Proceso de Montaje

 primero en una protoboard insertamos los 8 LEDs con sus respectivas resistencias de protección, estos diodos van conectados a la tierra del arduino.

luego del montaje de los diodos y las resistencias, conectamos el integrado IC 74HC595, sus entradas a tierra, a voltaje y la conexión a los diodos

ya después de conectada la parte eléctrica del circuito, procedemos a generar el código en arduino y processing (el cual ya lo apreciamos anteriormente).

Vídeo