Laboratorio 4

Descripción.

Controlar 8 LEDs desde el Arduino, a través de un IC 74HC595, en el que se define 9 patrones de movimiento controlados desde una interfaz gráfica en Processing/ControlP5.

Materiales

1. Computador con el IDE de Arduino Y Processing
2. Tarjeta Arduino
3. Cable USB; COM5
4. Protoboard
5. 8 LEDs + Resistencias 220Ω
6. Cables macho-macho
7. IC 74HC595

Diagrama del Montaje en la Protoboard

Diagrama Esquemático del Circuito

Diagrama PCB equivalente

Proceso del Montaje paso a paso (Fotos)

Paso 1: Ubicar los leds y resistencias.

Paso 2:  Al IC 74HC595 hacer las respectivas conexiones de al IC 

Paso 3: Verificar que todo este conectando, para ver su funcionamiento.

Código Fuente en Arduino (con comentarios)
/********** Proyecto **********
 * Laboratorio 04:
 * Universidad Santiago de Cali
 * Angelica maria campo Mancilla
 * Ejemplo de https://www.arduino.cc/en/Tutorial/ShftOut11
 * Controlar 8 LEDs desde el Arduino, a través de un IC 74HC595,
 * definiendo 9 patrones de movimiento que son
 * controlados desde una interfaz gráfica en Processing/ControlP5.

/********** Variables **********/

// Pin de Datos
int data_pin = 11;
// Pin de latch
int latch_pin = 9;
// Pin de Reloj
int clock_pin = 6;

// valores de las 9 secuencias//
// Guardamos el valor que recibimos via serial

int valor, val;
char letr;

int Sec1[4] = {3, 12, 48, 192};
int Sec2[6] = {128,2,4,8,128};
int Sec3[6] = {128,64,32,4,2,1};
int Sec4[2] = {255, 0};
int Sec5[12] = {1,128,2,64,4,32,8,16,4,32,2,64};
int Sec6[8] = {0,128,1,64,2,32,4,16};
int Sec7[5] = {2,4,8,32,128};
int Sec8[14] = {1,2,4,8,16,32,64,128,64,32,16,8,4,2};
int Sec9[3] = {8,1,64};


/********** Configuracion **********/

// Solo se ejecuta una vez, al iniciar o resetear el Arduino

void setup() {

  // La comunicacion serial sera a 9600 baudios
  Serial.begin(9600);

  // Pines de salida que controlan el 74HC595
  // se establecen estos pines a la salida para que pueda controlar el registro de desplazamiento

  pinMode(data_pin, OUTPUT);
  pinMode(latch_pin, OUTPUT);
  pinMode(clock_pin, OUTPUT);
}

/********** Ciclo Principal **********/

void loop() {

  // Se envian los datos, solo cuando se reciben datos
  if (Serial.available() > 0) {

    letr = Serial.read();
    val = Serial.parseInt();
    Serial.print(letr);
    Serial.println(val);

   }

 // Se condiciona si el numero enviado está entre las
 // opciones y ejecuta el patron determinado

  if (val == 1) { //Si es 1 inicie funcion de secuencia1
    secuencia1();}
  if (val == 2) { //Si es 2 inicie funcion de secuencia2
    secuencia2();}
  if (val == 3) { //Si es 3 inicie funcion de secuencia3
    secuencia3();}
  if (val == 4) { //Si es 4 inicie funcion de secuencia4
    secuencia4();}
  if (val == 5) { //Si es 5 inicie funcion de secuencia5
    secuencia5();}
  if (val == 6) { //Si es 6 inicie funcion de secuencia6
    secuencia6();}
  if (val == 7) { //Si es 7 inicie funcion de secuencia7
    secuencia7();  }
  if (val == 8) { //Si es 8 inicie funcion de secuencia8
    secuencia8();}
  if (val == 9) { //Si es 9 inicie funcion de secuencia9
    secuencia9();
  }
}

// **** Funciones ***** //
// codigo de las funciones para mostrar los patrones en cada caso.

void secuencia1() {

  //recorre el arreglo donde se define la secuencia
  for (int i = 0; i < 4; i++) {
    // toma el latch_pin en bajo (LOW), para que los LEDs no cambien, mientras
    // se envian los datos (en bits).
    digitalWrite(latch_pin, LOW);
    shiftOut(data_pin, clock_pin, MSBFIRST, Sec1[i]);
    //toma el latch_pin en alto (HIGH), para que los LEDs se iluminen
    digitalWrite(latch_pin, HIGH);
    // se hace una pausa antes del siguiente valor
    delay(200);
  }}

void secuencia2() {
  //recorre el arreglo donde se define la secuencia
  for (int i = 0; i < 6; i++) {
    // toma el latch_pin en bajo (LOW), para que los LEDs no cambien, mientras
    // se envian los datos (en bits).
    digitalWrite(latch_pin, LOW);
    shiftOut(data_pin, clock_pin, MSBFIRST, Sec2[i]);
    //toma el latch_pin en alto (HIGH), para que los LEDs se iluminen
    digitalWrite(latch_pin, HIGH);
    // se hace una pausa antes del siguiente valor
    delay(200);
  }
}

void secuencia3() {
  //recorre el arreglo donde se define la secuencia
  for (int i = 0; i < 6; i++) {
    // toma el latch_pin en bajo (LOW), para que los LEDs no cambien, mientras
    // se envian los datos (en bits).
    digitalWrite(latch_pin, LOW);
    shiftOut(data_pin, clock_pin, MSBFIRST, Sec3[i]);
    //toma el latch_pin en alto (HIGH), para que los LEDs se iluminen
    digitalWrite(latch_pin, HIGH);
    // se hace una pausa antes del siguiente valor
    delay(200);
  }
}

void secuencia4() {
  //recorre el arreglo donde se define la secuencia
  for (int i = 0; i < 2; i++) {
    // toma el latch_pin en bajo (LOW), para que los LEDs no cambien, mientras
    // se envian los datos (en bits).
    digitalWrite(latch_pin, LOW);
    shiftOut(data_pin, clock_pin, MSBFIRST, Sec4[i]);
    //toma el latch_pin en alto (HIGH), para que los LEDs se iluminen
    digitalWrite(latch_pin, HIGH);
    // se hace una pausa antes del siguiente valor
    delay(200);
  }
}

void secuencia5() {

//recorre el arreglo donde se define la secuencia
  for (int i = 0; i < 12; i++) {
    // toma el latch_pin en bajo (LOW), para que los LEDs no cambien, mientras
    // se envian los datos (en bits).
    digitalWrite(latch_pin, LOW);
    shiftOut(data_pin, clock_pin, MSBFIRST, Sec5[i]);
    //toma el latch_pin en alto (HIGH), para que los LEDs se iluminen
    digitalWrite(latch_pin, HIGH);
    // se hace una pausa antes del siguiente valor
    delay(200);
  }
}
void secuencia6() {
//recorre el arreglo donde se define la secuencia
  for (int i = 0; i < 8; i++) {
    // toma el latch_pin en bajo (LOW), para que los LEDs no cambien, mientras
    // se envian los datos (en bits).
    digitalWrite(latch_pin, LOW);
    shiftOut(data_pin, clock_pin, MSBFIRST, Sec6[i]);
    //toma el latch_pin en alto (HIGH), para que los LEDs se iluminen
    digitalWrite(latch_pin, HIGH);
    // se hace una pausa antes del siguiente valor
    delay(200);
  }
}
 void secuencia7() {
//recorre el arreglo donde se define la secuencia
  for (int i = 0; i < 5; i++) {
    // toma el latch_pin en bajo (LOW), para que los LEDs no cambien, mientras
    // se envian los datos (en bits).
    digitalWrite(latch_pin, LOW);
    shiftOut(data_pin, clock_pin, MSBFIRST, Sec7[i]);
    //toma el latch_pin en alto (HIGH), para que los LEDs se iluminen
    digitalWrite(latch_pin, HIGH);
    // se hace una pausa antes del siguiente valor
    delay(200);
  }
}
void secuencia8() {
  //recorre el arreglo donde se define la secuencia
  for (int i = 0; i < 14; i++) {
    // toma el latch_pin en bajo (LOW), para que los LEDs no cambien, mientras
    // se envian los datos (en bits).
    digitalWrite(latch_pin, LOW);
    shiftOut(data_pin, clock_pin, MSBFIRST, Sec8[i]);
    //toma el latch_pin en alto (HIGH), para que los LEDs se iluminen
    digitalWrite(latch_pin, HIGH);
    // se hace una pausa antes del siguiente valor
    delay(200);
  }}
  void secuencia9() {
  //recorre el arreglo donde se define  la secuencia
  for (int i = 0; i < 3; i++) {
    // toma el latch_pin en bajo (LOW), para que los LEDs no cambien, mientras
    // se envian los datos (en bits).
    digitalWrite(latch_pin, LOW);
    shiftOut(data_pin, clock_pin, MSBFIRST, Sec9[i]);
    //toma el latch_pin en alto (HIGH), para que los LEDs se iluminen
    digitalWrite(latch_pin, HIGH);
    // se hace una pausa antes del siguiente valor
    delay(200);
  }
}


/********** Fin ***********/

Código Fuente en Processing (con comentarios)



/********** Proyecto **********
 * Universidad santiago de cali
 * Angelica maria Campo Mancilla
 * Ejemplo: http://forum.processing.org/one/topic/radiobutton-implementation.html
 * Laboratorio 04: se Controlan 8 LEDs
 * desde el Arduino, a través de un IC 74HC595,
 * definiendo 9 patrones de movimiento que son
 * controlados desde una interfaz gráfica en Processing/ControlP5.*/

// Importamos las librerías de ControlP5 y Serial

import controlP5.*;

import processing.serial.*;A

//****** Objetos ********//

ControlP5 cp5;
RadioButton radioButton;
Serial serial;

//**** variables*****//
 
int colorDeFondo = color (100,200,20);

//*****configuracion*****//
// Solo se ejecuta una vez, al iniciar el Sketch//

void setup()
{  
// Tamaño de la Ventana//
  size(260, 150);

// Creamos el objeto de ControlP5//
  cp5 = new ControlP5(this);

// Creamos el objeto radiobutton//

  radioButton = cp5.addRadioButton("radioButton")

// Se Definen las caracteriticas de la interfaz//

  .setPosition(20, 20)
  .setSize(30, 30)
  .setColorForeground(color(200))
  .setColorActive(color(30))
  .setColorLabel(color(300))
  .setItemsPerRow(3)
  .setSpacingColumn(60)
  .setSpacingRow(10)

// Se crean los 9 botones, Para los 9 patrones//

  .addItem(" A ",1)
  .addItem(" B ",2)
  .addItem(" C", 3)
  .addItem(" D", 4)
  .addItem(" E", 5)
  .addItem(" F", 6)
  .addItem(" G", 7)
  .addItem( "H", 8)
  .addItem(" I", 9) ;

 // Creamos el objeto del puerto Serial//

  serial = new Serial(this, Serial.list()[0], 9600);}

// Se dibuja el color de fondo//

void draw() {background(colorDeFondo);}

//**** Ciclo principal ****//
// Contol de los Botones//

void keyPressed() {

  switch(key) {
    case('0'):
    radioButton.deactivateAll();
    break;
    case('1'):
    radioButton.activate(0);
    break;
    case('2'):
    radioButton.activate(1);
    break;
    case('3'):
    radioButton.activate(2);
    break;
    case('4'):
    radioButton.activate(3);
    break;
    case('5'):
    radioButton.activate(4);
    break;
    case('6'):
    radioButton.activate(5);
    break;
    case('7'):
    radioButton.activate(6);
    break;
    case('8'):
    radioButton.activate(7);
    break;
    case('9'):
  }
}
/********** Funciones **********/

void controlEvent(ControlEvent evento) {

  if (evento.isFrom(radioButton)) {

    int total = 0;
    total = (int)evento.getValue();
    println("\nValor a ser enviado por Serial = " + total);
    serial.write("P"+total); }}


/********** Fin ***********/
Video del Funcionamiento