jueves, 26 de marzo de 2015

LABORATORIO 6

DESCRIPCIÓN:

Este laboratorio consiste  en controlar 8 LEDs desde el Arduino, a través de un 74HC545, definiendo mínimo 8 patrones de movimiento que son controlados desde una interfaz gráfica en Processing/ControlP5.


MATERIALES:
  • Arduino 
  • 8 LEDs
  • resistencias
  • 1 integrado 74HC545 
  • MONTAJE PASO A PASO:
    • montamos los LEDs en la protoboard

    • posteriormente le añadimos una resistencia a cada LED para protegerlos.

    • montamos el integrado 74HC545 cin sus respectivas conexiones a 5V y a tierra.

    • realizamos las conexiones desde el 74HC545 a los diodos LEDs y a los respectivos pines del Arduino que escogimos en nuestra programación.

  • DIAGRAMAS  (USANDO FRITZING)

    • En protoboard

    • Esquemático 
    • En PCB
  • VIDEO DEL FUNCIONAMIENTO:
  • CÓDIGO FUENTE EN ARDUINO:
    1:  /** Laboratorio 6: controlar 8 LEDS desde Processing/ControlP5  
    2:   * utilizando un 74HC525  
    3:   * Autor: FANOR STIWAR ZAPATA  
    4:   */  
    5:     
    6:  // definimos la cantidad de pines que vamos a usar como PIN //  
    7:  #define PIN 3  
    8:     
    9:  // se declaran los pines que utilizaremos  
    10:  // que van a ser usados por el integrado respectivamente  
    11:     
    12:  const int Latch = 8;  
    13:  const int Clock = 9; //el pin SH_CP osea Clock debe ser PWM(~) //  
    14:  const int Data = 7;  
    15:     
    16:  int Pins[PIN] = {Data,Latch,Clock};  
    17:     
    18:  // Inicializamos las variables que vamos a utilizar  
    19:  int Lect = 0;  
    20:  boolean OnLed = false;  
    21:  int Dato = 0;  
    22:  int i = 0;  
    23:  int Led[]={1,2,4,8,16,32,64,128};  
    24:     
    25:  // Ciclo para activar los tres pines como salida  
    26:  void setup() {  
    27:   for (int j=0; j<PIN; j++){  
    28:    pinMode(Pins[j], OUTPUT);  
    29:   }  
    30:   //Comunicación serial a 9600bps  
    31:   Serial.begin(9600);  
    32:  }  
    33:     
    34:  // Recibe la información de manera serial del processing  
    35:  void loop()  
    36:  {  
    37:   if (Serial.available()>0) {  
    38:      
    39:    Lect = Serial.read(); //Leemos el Dato  
    40:      
    41:    //Se ingresa cuando OnLed es verdadero  
    42:    //osea cuando algun Led esta en On "1"  
    43:    if (OnLed)  
    44:    {  
    45:     Suma(Lect);  
    46:     On(Dato);  
    47:     OnLed = false;  
    48:    }  
    49:    else  
    50:    {  
    51:     //Se recibe la info si el Led esta On u Off "1" o "0"  
    52:     i = Lect;  
    53:     OnLed = true;  
    54:    }  
    55:   }  
    56:  }  
    57:     
    58:  // Le va adicionando o sustraendo al Dato el valor del  
    59:  // Led encendido o apagado  
    60:  void Suma(int estadoLED){  
    61:   if(estadoLED==0)  
    62:   {  
    63:    Dato = Dato-Led[i];  
    64:   }else{  
    65:    Dato = Dato+Led[i];  
    66:   }   
    67:  }  
    68:     
    69:  // Función para enviar los datos al Integrado IC 74HC595  
    70:  // y se usa shiftOut para que el valor se lea en los ocho Leds  
    71:  void On(int Valor)  
    72:  {  
    73:   digitalWrite(Latch, LOW);  
    74:   shiftOut(Data, Clock, MSBFIRST, Valor);  
    75:   digitalWrite(Latch, HIGH);  
    76:  }  
    
  • CÓDIGO FUENTE EN PROCESSING:
  • 1:  /** Laboratorio 6: controlar 8 LEDS desde Processing/ControlP5  
    2:   * utilizando un 74HC525  
    3:   * Autor: fanor stiwar zapata   
    4:   */  
    5:     
    6:  // Se utiliza las librerias ControlP5 y Serial del Processing  
    7:  import controlP5.*;  
    8:  import processing.serial.*;  
    9:     
    10:  // Se define la variable cP5 del tipo ControlP5  
    11:  ControlP5 cP5;  
    12:     
    13:  // Se le da nombres al Serial  
    14:  Serial serial;  
    15:     
    16:  int[] led = new int[] {  
    17:   0, 0, 0, 0, 0, 0, 0, 0  
    18:  };  
    19:     
    20:  // Configuración inicial  
    21:  void setup() {  
    22:   size(590, 250); //Tamaño de la ventana  
    23:   noStroke();  
    24:     
    25:   cP5 = new ControlP5(this); //Crea el objeto ControlP5  
    26:     
    27:   // Crea el Knob del color Rojo  
    28:   for (int i=0; i<led.length; i++)  
    29:   {  
    30:    cP5.addToggle("led"+i, 35+i*70, 140, 30, 30)  
    31:     .setMode(ControlP5.SWITCH);  
    32:   }  
    33:     
    34:   String puerto = Serial.list()[0];  
    35:   //Comunicación serial a 9600bps  
    36:   serial = new Serial(this, puerto, 9600);  
    37:  }  
    38:     
    39:  // Cada uno de los circuilos hecho toma el color determinado  
    40:  // del Led que se tiene en la protoboard  
    41:  void draw() {  
    42:   background(0xFF444444);  
    43:   fill(led[0] == 0 ? 0xFF222222 : color(255, 255, 0));  
    44:   ellipse(50, 100, 50, 50);  
    45:   for (int i=1; i<4; i++) {  
    46:    fill(led[i] == 0 ? 0xFF222222 : color(255, 0, 0));  
    47:    ellipse(50+i*70, 100, 50, 50);  
    48:   }  
    49:   for (int i=4; i<led.length; i++) {  
    50:    fill(led[i] == 0 ? 0xFF222222 : color(0, 255, 0));  
    51:    ellipse(50+i*70, 100, 50, 50);  
    52:   }  
    53:    fill(255);  
    54:    textFont(createFont("Gill Sans Ultra Bold", 50));  
    55:    text("Enciende un LED", 40, 50);  
    56:    fill(255);  
    57:    textSize(25);  
    58:    text("Juan Camilo Fernández López", 120, 230);  
    59:  }  
    60:     
    61:  // Como se va a actuar cuando ocurra un evento con los botones  
    62:  void controlEvent(ControlEvent evento) {  
    63:   String nombre = evento.getController().getName();  
    64:   int valor = int(evento.getController().getValue());  
    65:     
    66:   // Guarda el valor de cada boton  
    67:   for (int i=0; i<led.length; i++) {  
    68:    if (nombre.equals("led"+i)) {  
    69:     led[i] = valor;  
    70:     serial.write(i);  
    71:     serial.write(valor);  
    72:     println("evento: " + i + " / valor: "+valor);  
    73:    }  
    74:   }  
    75:  }  
    


LABORATORIO 5

DESCRIPCIÓN:

 consiste el controlar un LED RGB desde el Arduino, via una interfaz grafica en Processing/ControlP5 para controlar la intensidad de  los LEDs (rojo, verde, azul) del RGB. 


MATERIALES:
  • Arduino 
  • 1 LED RGB
  • 3 resistencias

MONTAJE PASO A PASO:
  • montamos el LED RGB en la protoboard
  • realizamos las conexiones del cicuito en la protoboard con el arduino, teniendo el cuenta el GND y el pin out para cada color del  LED según nuestra programación.

  • Haga clic en Opciones
  • DIAGRAMAS  (FRITZING)

    • En protoboard
    • ESQUEMATICO



    •  








    • En PCB










    • VIDEO DEL FUNCIONAMIENTO:












CÓDIGO FUENTE EN ARDUINO:

1:  //** Laboratorio #5: controlar 1 LED RGB desde Processing/ControlP5  
2:  para controlar la intensidad de cada color del RGB  
3:   * Autor: FANOR ZAPATA   
4:   */  
5:     
6:  int valor=0;  
7:     
8:  #define MAX 9  
9:  int led[MAX]={2, 3 , 5};  
10:  int valorR=100;  
11:  int valorG=100;  
12:  int valorB=100;  
13:     
14:     
15:  void setup(){  
16:   Serial.begin(9600);  
17:   for(int pin=0; pin<=MAX;pin++){  
18:    pinMode(led[pin], OUTPUT);  
19:      
20:   }  
21:  }  
22:     
23:     
24:  void loop(){  
25:     
26:   if (Serial.available()>0){  
27:    valor=Serial.read();  
28:    if (valor=='R'){  
29:    valorR=Serial.parseInt();  
30:    }  
31:    if (valor=='G'){  
32:    valorG=Serial.parseInt();  
33:    }  
34:      
35:    if (valor=='B'){  
36:    valorB=Serial.parseInt();  
37:    }  
38:   }  
39:   prender(led[0], valorR);  
40:   prender(led[1], valorG);  
41:   prender(led[2], valorB);  
42:  }  
43:  void prender(int le, int tem){  
44:   analogWrite(le, tem);  
45:     
46:  }  
47:  void apagar(int le, int tem){  
48:   analogWrite(le, tem);  
49:     
50:     
51:  }  
52:   pinMode(A2, INPUT);  
53:   pinMode(A3, INPUT);  
54:     
55:   pinMode(4, OUTPUT);  
56:   pinMode(5, OUTPUT);  
57:   pinMode(6, OUTPUT);  
58:  }  
59:     
60:  void loop() {  
61:     
62:   // codigo para que sea repetitivo y dependa de las entradas analogas//  
63:  int valorR=analogRead (A1)/4;  
64:  int valorB=analogRead (A2)/4;  
65:  int valorG=analogRead (A3)/4;  
66:     
67:  analogWrite (4, valorR);  
68:  analogWrite (5, valorB);  
69:  analogWrite (6, valorR);  
70:     
71:     
72:  }  

CODIGO FUENTE EN PROCESSING/CONTROLP5:
1:  //** Laboratorio #5: controlar 1 LED RGB desde Processing/ControlP5  
2:  para controlar la intensidad de cada color del RGB  
3:   * Autor: FANOR STIWAR ZAPATA   
4:   */  
5:     
6:   // Importamos las librerias de controlP5 y serial//  
7:     
8:  import controlP5.*;  
9:  import processing.serial.*;  
10:     
11:  // creamos las variables para controlP5, el Slider y el puerto serial  
12:     
13:  ControlP5 cp5;  
14:  Knob KnobA;  
15:  Knob KnobB;  
16:  Knob KnobC;  
17:  Serial serial;  
18:  int valR = 128;   
19:  int valG = 128;   
20:  int valB = 128;  
21:     
22:   // Solo se ejecuta una vez, al iniciar el Sketch//  
23:     
24:  void setup() {  
25:     
26:   // Tamaño de la Ventana //   
27:     
28:   size(800, 450);  
29:   noStroke();  
30:     
31:   // Creamos el objeto de ControlP5//  
32:     
33:   cp5 = new ControlP5(this);  
34:     
35:   // Creamos el objeto de Slider//  
36:     
37:   KnobA = cp5.addKnob("R", 0, 255, 128, 40, 40, 200);  
38:   KnobA.setColor( new CColor(  
39:   0xFFAA0000, 0xFF550000, 0xFFFF0000,   
40:   0xFFFFFFFF, 0xFFFFFFFF));  
41:     
42:   KnobB = cp5.addKnob("G", 0, 255, 128, 240+10, 40, 200);  
43:   KnobB.setColor( new CColor(  
44:   0xFF00AA00, 0xFF005500, 0xFF00FF00,   
45:   0xFFFFFFFF, 0xFFFFFFFF));  
46:     
47:   KnobC = cp5.addKnob("B", 0, 255, 128, 440+20, 40, 200);  
48:   KnobC.setColor( new CColor(  
49:   0xFF0000AA, 0xFF000055, 0xFF0000FF,   
50:   0xFFFFFFFF, 0xFFFFFFFF));  
51:     
52:   // Creamos el objeto del serial//  
53:     
54:   serial = new Serial(this, Serial.list()[1], 9600);  
55:  }  
56:     
57:     
58:  void draw() {  
59:   background(0xFF444444);  //*color gris en el fondo *//  
60:     
61:     
62:   /*definir el color de relleno combinando los valores  
63:    de los colores de los 3 Knobs  
64:   */  
65:     
66:   fill(valR, valG, valB);   
67:     
68:   // dibujar el rectángulo con ese color//  
69:     
70:   rect(20, 300, 750, 120);  
71:  }  
72:     
73:   // Cuando ocurra un evento, aquí lo procesamos//  
74:     
75:  void controlEvent(ControlEvent evento) {  
76:     
77:   // Obtenemos el nombre y el valor del evento//  
78:     
79:   String nombre = evento.getController().getName();  
80:   int valor = int(evento.getController().getValue());  
81:   println(nombre + valor);  
82:   serial.write(nombre+valor);  
83:     
84:   // guardar el valor en la variable para cada color  
85:     
86:   if (nombre == "R") {  
87:    valR = valor;  
88:   }  
89:   if (nombre == "G") {  
90:    valB = valor;  
91:   }  
92:   if (nombre == "B") {  
93:    valG = valor;  
94:   }  
95:     
96:  }  
97:     















LABORATORIO 4

DESCRIPCIÓN:

 consiste el controlar un LED RGB desde el Arduino, vía PWM con 3 potenciómetros, uno para cada color (rojo, verde, azul),  controlaremos la intensidad de cada color. 


MATERIALES:
  • Arduino 
  • 1 LED RGB
  • 3 resistencias
  • 3 potenciometros 

MONTAJE PASO A PASO:
  • montamos el LED RGB    en la protoboard

  • realizamos las conexiones del cicuito en la protoboard con el arduino, teniendo el cuenta el GND y el pin out para cada color del  LED según nuestra programación.

  • DIAGRAMAS  ( FRITZING)
PCB 











VIDEO DEL FUNCIONAMIENTO:

CÓDIGO FUENTE EN ARDUINO:
1:  /********** Proyecto **********  
2:   * Laboratorio 4:  
3:   * Autor: FANOR STIWAR ZAPATA  
4:   **DESCRICION: Controlar un LED RGB desde el Arduino, vía PWM con 3 potenciómetros, uno para cada color.  
5:     
6:  void setup() {  
7:     
8:   /* Declaramos los pines para las entradas (potenciometros)  
9:   y para las salidas (LEDs del RGB) */  
10:     
11:   pinMode(A1, INPUT);  
12:   pinMode(A2, INPUT);  
13:   pinMode(A3, INPUT);  
14:     
15:   pinMode(4, OUTPUT);  
16:   pinMode(5, OUTPUT);  
17:   pinMode(6, OUTPUT);  
18:  }  
19:     
20:  void loop() {  
21:     
22:   // codigo para que sea repetitivo y dependa de las entradas analogas//  
23:  int valorR=analogRead (A1)/4;  
24:  int valorB=analogRead (A2)/4;  
25:  int valorG=analogRead (A3)/4;  
26:     
27:  analogWrite (4, valorR);  
28:  analogWrite (5, valorB);  
29:  analogWrite (6, valorR);  
30:     
31:     
32:  }  


laboratorio 3

DESCRIPCIÓN:

Este laboratorio consiste el controlar el tiempo de encendido y apagado de 8 LEDs, via una interfaz grafica en Processing/ControlP5.  que a su vez el encendido se desplaza de izquierda a derecha y viceversa, usando arduino.


MATERIALES:
Arduino
8 LEDs
8 resistencias

MONTAJE PASO A PASO:
  • montamos los LEDs en la protoboard y las respectivas resistencias 

  • DIAGRAMAS  ( FRITZING)
    • En protoboard

    En esquematico
  •  En pcb 

  • VIDEO DEL FUNCIONAMIENTO:



  • CÓDIGO FUENTE EN ARDUINO:
  • 
    1:  /********** Proyecto **********  
    2:   * Laboratorio 3:  
    3:   * Autor: FANOR STIWAR ZAPATA  
    4:   **DESCRICION: controlar 8 LEDs desde controlP5 con una  
    5:   interfaz grafica  
    6:     
    7:   */  
    8:     
    9:  // Conectamos el LED a un pin PWM //  
    10:  int led = 9;  
    11:     
    12:  int valor = 0;  
    13:     
    14:  // Si solo se ejecutara una vez el Arduino //  
    15:  void setup() {  
    16:     
    17:   // Definimos la comunicacion serial //  
    18:   Serial.begin(9600);  
    19:     
    20:   // ponemos el pin de salida (ya elegido anteriormente)  
    21:   pinMode(led, OUTPUT);  
    22:  }  
    23:     
    24:  // Ciclo de ejecucion //  
    25:  void loop() {  
    26:     
    27:   if (Serial.available() > 0) {  
    28:      
    29:    // Leer el valor de el serial //  
    30:    valor = Serial.read();  
    31:      
    32:    // Cambiar la intensidad de iluminacion del LED //  
    33:    analogWrite(led, valor);  
    34:   }   
    35:  }
    
    
      
    
    CÓDIGO FUENTE EN PROCESSING:
    /********** Proyecto **********  
    2:   * Laboratorio 3:  
    3:   * Autor: FANOR STIWAR ZAPATA  
    4:   **DESCRICION: controlar 8 LEDs desde controlP5 con una  
    5:   interfaz grafica  
    6:     
    7:  // Importamos las librerías de ControlP5 y Serial //  
    8:  import controlP5.*;  
    9:  import processing.serial.*;  
    10:     
    11:  // Declaramos las variables para ControlP5, el Slider y el puerto Serial //  
    12:  ControlP5 cp5;  
    13:  Slider slider;  
    14:  Serial serial;  
    15:     
    16:  // para ejecutarse al iniciar el Sketch //  
    17:  void setup() {  
    18:     
    19:   // Definimos las dimensiones de la Ventana //  
    20:   size(600, 400);  
    21:     
    22:   // Creamos el objeto de ControlP5 //  
    23:   cp5 = new ControlP5(this);  
    24:     
    25:   // Creamos el objeto Slider //  
    26:   slider = cp5.addSlider("valor", 0, 255, 128, 40, 40, 300, 40);  
    27:     
    28:   // Creamos el objeto del puerto Serial//  
    29:   serial = new Serial(this, Serial.list()[5], 9600);  
    30:  }  
    31:     
    32:  // Se ejecuta N frames por segundo //  
    33:  void draw() {  
    34:     
    35:  }  
    36:     
    37:  // Llevamos el control de los eventos, aqui se procesan //  
    38:  void controlEvent(ControlEvent evento) {  
    39:     
    40:   // Damos nombre y valor al evento //  
    41:   String nombre = evento.getController().getName();  
    42:   int valor = int(evento.getController().getValue());  
    43:     
    44:   // Envíamos el valor al Arduino a través del Serial //  
    45:   serial.write(valor);  
    46:     
    47:   // sacamos la consola //  
    48:   println(nombre + ":" + valor);  
    49:  }  
    
    
    
    
    
    

LABORATORIO 2


 DESCRIPCIÓN DEL LABORATORIO
 consiste el controlar el tiempo de encendido y apagado de 8 LEDs usando dos potenciometros (un potenciometro para los tiempos de encendido, otro potenciometro para los tiempos de apagado).

MATERIALES:
  • Arduino 
  • 8 LEDs
  • 8 resistencias
  • 2 potenciometros (10 K)
  • Computador (con el IDE de Arduino, y el driver adecuado instalados)

MONTAJE PASO A PASO:
  • montamos  en la protoboard
















DIAGRAMAS  ( FRITZING)
  • En protoboard



  • En ESQUEMATICO





  • EN PCB


    • VIDEO DEL FUNCIONAMIENTO:






  • CÓDIGO FUENTE EN ARDUINO. 

  • 1:  /********** Proyecto **********  
    2:   * Laboratorio 02: 8 LEDs en linea controlados con Potenciometros  
    3:   * Autor: FANOR STIWAR ZAPATA  
    4:   * Descripcion:  
    5:   *  Mover un LED encendido de Izquierda a Derecha y viceversa  
    6:   *  con tiempos controlados por potenciometros  
    7:   * Conexiones:  
    8:   *  8 LEDs + resistencias a los pines D2 .. D9  
    9:   *  2 Potenciometros a los pines A0 y A1  
    10:   * Version: 1  
    11:   */  
    12:     
    13:  /********** Librerias **********/  
    14:     
    15:  // ninguna  
    16:     
    17:  /********** Constantes **********/  
    18:     
    19:  #define POT1 A0  
    20:    
    21:  #define POT2 A1  
    22:    
    23:  #define TOTLED 8 // Total LEDs  
    24:    
    25:  /********** Objetos **********/  
    26:    
    27:  // ninguno  
    28:    
    29:  /********** Variables **********/  
    30:    
    31:  int led[TOTLED] = {  
    32:    
    33:  2, 3, 4, 5, 6, 7, 8, 9  
    34:    
    35:  };  
    36:    
    37:  int t_encendido = 500;  
    38:    
    39:  int t_apagado = 500;  
    40:    
    41:  /********** Configuracion **********/  
    42:    
    43:  void setup() {  
    44:    
    45:  int pos = 0;  
    46:    
    47:  while (pos < TOTLED) {  
    48:    
    49:  pinMode(led[pos], OUTPUT);  
    50:    
    51:  pos = pos + 1;  
    52:    
    53:  }  
    54:    
    55:  pinMode(POT1, INPUT);  
    56:    
    57:  pinMode(POT2, INPUT);  
    58:    
    59:  } // end setup()  
    60:    
    61:  /********** Ciclo Principal **********/  
    62:    
    63:  void loop() {  
    64:    
    65:  // Acciones  
    66:    
    67:  for (int pos = 0; pos < TOTLED; pos++) {  
    68:    
    69:  leer();  
    70:    
    71:  on(led[pos], t_encendido);  
    72:    
    73:  off(led[pos], t_apagado);  
    74:    
    75:  }  
    76:    
    77:  for (int pos = TOTLED - 2; pos > 0; pos--) {  
    78:    
    79:  leer();  
    80:    
    81:  on(led[pos], t_encendido);  
    82:    
    83:  off(led[pos], t_apagado);  
    84:    
    85:  }  
    86:    
    87:  } // end loop()  
    88:    
    89:  /********** Funciones **********/  
    90:    
    91:  void leer()  
    92:    
    93:  {  
    94:    
    95:  // Sensores  
    96:    
    97:  t_encendido = analogRead(POT1);  
    98:    
    99:  t_apagado = analogRead(POT2);  
    100:    
    101:  }  
    102:    
    103:  // Pone en +5V el pin indicado, durante tantos milisegundos  
    104:    
    105:  void on(int pin, int ms) {  
    106:    
    107:  digitalWrite(pin, HIGH);  
    108:    
    109:  delay(ms);  
    110:    
    111:  } // end on()  
    112:    
    113:  // Pone en GND el pin indicado, durante tantos milisegundos  
    114:    
    115:  void off(int pin, int ms) {  
    116:    
    117:  digitalWrite(pin, LOW);  
    118:    
    119:  delay(ms);  
    120:    
    121:  } // end off()  
    122:    
    123:  /********** Fin ***********/  
    




    laboratorio 1

     DESCRIPCIÓN DEL LABORATORIO
    A   Controlar 8 LEDs desde el Arduino, un LED encendido que se mueve de izquierda a derecha.
     _________________________________________________________________________________

    MATERIALES

    8 diodos led. 8 resistencias 330 o 220 ohmios
    80 cm's de alambre.
    1 potenciometro.
    1 Arduino UNO.
    1 Protoboard.






    CODIGO EN ARDUINO

    1. /********** Proyecto **********
    2. * Universidad Santiago de Cali
    3. *
    4. * Laboratorio 1: 8 LEDs en linea
    5. * Autor: fanor stiwar zapata
    6. * Descripcion:
    7. *     Mover un LED encendido de Izquierda a Derecha y viceversa
    8. * Conexiones:
    9. *     8 LEDs + resistencias a los pines D2 .. D9
    10. * Version: 1
    11.  
    12. void setup() {
    13.  
    14. //**declaramos las salidas//**  
    15.  pinMode(2,OUTPUT);
    16.  pinMode(3,OUTPUT);
    17.  pinMode(4,OUTPUT);
    18.  pinMode(5,OUTPUT);
    19.  pinMode(6,OUTPUT);
    20.  pinMode(7,OUTPUT);
    21.  pinMode(8,OUTPUT);
    22.  pinMode(9,OUTPUT);
    23.  
    24. }
    25.  
    26.  
    27.  
    28. void loop() {
    29.  
    30.  //configuramos el tiempo de encendido y apagado//
    31.  //para cada led por aparte//
    32.  
    33. digitalWrite(2,HIGH);
    34. delay(200);
    35. digitalWrite(2,LOW);
    36. delay(200);
    37.  
    38. digitalWrite(3,HIGH);
    39. delay(200);
    40. digitalWrite(3,LOW);
    41. delay(200);
    42.  
    43. digitalWrite(4,HIGH);
    44. delay(200);
    45. digitalWrite(4,LOW);
    46. delay(200);
    47.  
    48. digitalWrite(5,HIGH);
    49. delay(200);
    50. digitalWrite(5,LOW);
    51. delay(200);
    52.  
    53. digitalWrite(6,HIGH);
    54. delay(200);
    55. digitalWrite(6,LOW);
    56. delay(200);
    57.  
    58. digitalWrite(7,HIGH);
    59. delay(200);
    60. digitalWrite(7,LOW);
    61. delay(200);
    62.  
    63. digitalWrite(8,HIGH);
    64. delay(200);
    65. digitalWrite(8,LOW);
    66. delay(200);
    67.  
    68. digitalWrite(9,HIGH);
    69. delay(200);
    70. digitalWrite(9,LOW);
    71. delay(200);
    72. }


    PASO A PASO










    VIDEO DE FUNCIONAMIENTO