Felix Maocho

Para quien le interese lo que a nosotros nos interesa

2º Ejercicio de uso de pines digitales de Salida OUPUT – Semáforo

Félix Maocho
11/5/2016
.

Conocimientos que se precisan

Para realizar este ejercicio tal como aquí se resuelve solo se necesitan los conocimientos que se han ido explicando hasta el capítulo dedicado al “Uso de los pines digitales como salida” que podemos resumir en los siguientes puntos:

  • Saber escribir , compilar y “subir” a la Tarjeta Arduino un sketch
  • Conocer cuales son las partes fundamentales de un sketch, las funciones que la componen y cual es su utilidad
  • Conocer las funciones “int”

Material necesario

  • Tarjeta Arduino y cable de conexiones
  • Tarjeta de prototipado o “protoboard”
  • 9 Cables de conexiones macho/macho (preferiblemente 2 rojos, 2 verdes y 5 negros
  • 4 Resistencias de 220 Ω
  • 4 Led (preferible 2 de color rojo y 2 verdes)
  • 1 Cable de conexión macho/macho más, para comprobaciones de los circuitos (naranja o de cualquier otro color)

Simular un semáforo que regula el paso por el interior de un túnel.

Para una maqueta deseamos simular un semáforo que regule el paso a través de un corto túnel que no permite el cruce de dos trenes. Para que evitar que un tren arranque mientras que el otro no ha terminado de pasar, antes de poner un semáforo en verde se dejara que pasen los dos semáforos en rojo, tanto si hay o no trenes en el interior del túnel. Por tanto el funcionamiento será como sigue:

1º.- En un extremos se acaba de poner la luz en verde mientras que en el otro extremo está en rojo. Así se mantiene 25 segundos.

  • 2º.- Para estimular el paso de los últimos coches, el verde se pone parpadeante cinco veces con periodos de encendido y apagados de un segundo. o sea esta así 10 segundos más, mientras que el otro extremo esta en rojo, el resto no cambian
  • 3º.- El semáforo se pone en rojo en un extremo, pero para dar tiempo a que salgan los coches que estuvieran dentro del túnel el otro extremo también continua en rojo durante otros 10 segundos
  • Se repite el proceso, pero en este caso el es otro extremo el que se pone en verde

Hardware

Tenemos que colocar cuatro leds, uno rojo y uno verde en un extremos que llamaremos “Derecha” (D) y uno rojo y otro verde en el extremo que llamamos “Izquierda” (I)

La duda que se nos presenta es si necesitamos necesariamente cuatro pines para controlarlos, pues en principio parece que si un led esta rojo en un extremo está verde en el contrario por tanto un solo circuito que diera corriente a los dos led sería suficiente.

¿Lo es así en nuestro caso?. – No, porque en la condición 2ª hay que poner intermitente el verde mientras que en el otro extremo esta fijo el rojo y en la 3ºº se exige poner los dos extremos en rojo mientras que los verdes están apagados

Así pues necesitamos utilizar cuatro pines digitales que vamos a llamar:

  • Derecha Verde DV y le adjudicamos el pin 10
  • Derecha Rojo DR y le adjudicamos el pin 11
  • Izquierda Verde IV y le adjudicamos el pin 12
  • Izquierda Rojo IR y le adjudicamos el pin 13

El hardware será por tanto como indica el esquema siguiente.

Sketch5_5_2_Semaforo_bb

Software

El nombre que le damos es Sketch E5.2, (E de ejercicio 5 del capítulo 5 y 2 por ser el segundo.

/* Sketch E5.2 Simular de semáforo
* Izquierda (I), Derecha (D), Verde (V), Rojo (R )
* MAYUSCULAS = encendido, minúsculas = apagado
* 1º.- Circulación I >> D (IV) (ir) –- (dv) (DR) tiempo1
* 2º.- Circonio I >> D (IV) parpadea 5 veces (tiempo2) resto no cambian
* 3º.- No hay circulación (iv) (IR) –- (dv) (DR) tiempo3
* Se repite el proceso, pero en este caso es el otro extremo el que se pone en verde
* Repetir el ciclo
*/
// Área de definición de variables y parámetros ********************
int pindv = 10;
int pindr = 11;
int piniv = 12;
int pinir = 13;
int tiempo1 = 4000; // duración del 1º periodo
int tiempo2 = 400; // separación entre destellos cortos
int tiempo3 = 2000; // duración del 3º periodo
// Función setup ********************************************
void setup() {
// Pines abiertos como OUTPUT
pinMode(pindv, OUTPUT); // Pin 10
pinMode(pindr, OUTPUT); // Pin 11
pinMode(piniv, OUTPUT); // Pin 12
pinMode(pinir, OUTPUT); // Pin 13
}
// Función loop ********************************************
void loop() {
// 1º.- Circulación I >> D (IV) (ir) –- (dv) (DR) tiempo1 ***************
digitalWrite(piniv, HIGH);
digitalWrite(pindr, HIGH);
delay(tiempo1);
// 2º.- Circonio I >> D (IV) parpadea 5 veces (tiempo2) resto no cambian ****
// 1º Vez ***************************************************
digitalWrite(piniv, LOW);
delay(tiempo2);
digitalWrite(piniv, HIGH);
delay(tiempo2);
// 2º Vez ***************************************************
digitalWrite(piniv, LOW);
delay(tiempo2);
digitalWrite(piniv, HIGH);
delay(tiempo2);
// 3º Vez ***************************************************
digitalWrite(piniv, LOW);
delay(tiempo2);
digitalWrite(piniv, HIGH);
delay(tiempo2);
// 4º Vez ***************************************************
digitalWrite(piniv, LOW);
delay(tiempo2);
digitalWrite(piniv, HIGH);
delay(tiempo2);
//5º Vez ***************************************************
digitalWrite(piniv, LOW);
delay(tiempo2);
digitalWrite(piniv, HIGH);
delay(tiempo2);
// * 3º.- No hay circulación (iv) (IR) –- (dv) (DR) tiempo3 ****************
digitalWrite(piniv, LOW);
digitalWrite(pinir, HIGH);
delay(tiempo3);
// Fin del paso en una dirección apagamos los semáforos que están encendidos
digitalWrite(pindr, LOW);
// digitalWrite(pin1r, LOW); (no es necesario apagar y encender)
// *******************************************************
// Se repite el proceso, pero en este caso el es otro extremo el que se pone en verde
// sea cambiar en los pin la “d” por la “i” y viceversa
// 1º.- Circulación I >> D (IV) (ir) –- (dv) (DR) tiempo1 ***************
digitalWrite(pindv, HIGH);
// digitalWrite(pinir, HIGH); (no es necesario apagar y encender)
delay(tiempo1);
// 2º.- Circonio I >> D (IV) parpadea 5 veces (tiempo2) resto no cambian ****
// 1º Vez ***************************************************
digitalWrite(pindv, LOW);
delay(tiempo2);
digitalWrite(pindv, HIGH);
delay(tiempo2);
// 2º Vez ***************************************************
digitalWrite(pindv, LOW);
delay(tiempo2);
digitalWrite(pindv, HIGH);
delay(tiempo2);
// 3º Vez ***************************************************
digitalWrite(pindv, LOW);
delay(tiempo2);
digitalWrite(pindv, HIGH);
delay(tiempo2);
// 4º Vez ***************************************************
digitalWrite(pindv, LOW);
delay(tiempo2);
digitalWrite(pindv, HIGH);
delay(tiempo2);
//5º Vez ***************************************************
digitalWrite(pindv, LOW);
delay(tiempo2);
digitalWrite(pindv, HIGH);
delay(tiempo2);
// * 3º.- No hay circulación (iv) (IR) –- (dv) (DR) tiempo3 ****************
digitalWrite(pindv, LOW);
digitalWrite(pindr, HIGH);
delay(tiempo3);
// Fin del paso en una dirección apagamos los semáforos que están encendidos
// digitalWrite(pindr, LOW); (no es necesario apagar y encender)
digitalWrite(pinir, LOW);
}

Ven el funcionamiento del programa

 

Puntuación

  • Si ha realizado el mismo ejercio compara sus resultados con este y proceda a autopuntuarse
  • Si has conseguido que tu ejercicio funcione como este tienes 5 puntos
  • Si alguien que no lo ha hecho lo entiende con facilidad un punto mas
  • Si se entiende con más facilidad otro punto mas
  • Si tiene menos lineas de código que este un punto mas y otro punto por cada 19% de diferencia
  • Si utiliza recursos de la tarjeta de menos importancia otro punto más
  • Si quieres mandame el programa en un email y (si tengo tiempo) te lo comento. Agradeceré ideas de ejercicios que se puedan hacer con ester nivel de conocimientos, sean solo la idea o su confección concreta.

Según este baremo mi puntuación sería

  • 5 puntos por funcionar según lo previsto
  • 1 Punto por estar escrito claro y comprensible

Total 6 puntos, aprobado alto, podría mejorar la nota reduciendo el número de lineas pero para ello necesito utilizar conocimientos que aun no he explicado. Cambien podría mejorar utilizando recursos de menos valor de la tarjeta, pero como en el caso anterior necesitamos para ello utilizar conocimientos que aun no he explicado.

Sugerencia para otro ejercicio

Cabria añadir más complicación a este ejercicio poniendo en cada semáforo un led naranja y utilizando dos pines digitales más, pero opino, que esa complejidad no añade mas enseñanza, Si lo desea como ejerció adicional puede hacerlo así como cambiar los tiempos de encendido y apagado o cualquiera de las especificaciones de funcionamiento.

Observaciones

Luces azules en vez de verdes

Como observaran las luces que deberían ser verdes son azules porque no he encontrado los led verdes, eso no cambia el ejercicio en absoluto.

Tiempo diferentes a los que solicita el enunciaado

Otro cambio ha sido el de las duraciones previstas inicialmente. Pues la experiencia indica que los tiempos inicialmente propuestos no eran poco adecuados a la hora de experimentar por ser muy largos por lo que he decidido cambiarlos a los siguientes, tiempo de circulación (tiempo1, 4s, tiempo de parpadeo (tiempo2), 0, 4s y tiempo de circulación interrumpida (tiempo3) 2s. Si en un trabajo real hubiera que poner finalmente los tiempos indicados inicialmente, una vez acabadas las pruebas se cambiaría en “Área de definición de variables y parámetros “ los tiempos y con una prueba final estaríamos seguros que el programa cumple al pie de la letra las especificaciones que se hicieron.

Complejidad no es equivalente a dificultad

Observen con que facilidad cualquier sencillo enunciado se trasforma en un programa complejo, sin embago complejo no es equivalente a complicado, Este programa es muy sencillo de comprender aunque resulte complejo y laborioso de poner a punto.

Funciones que se pueden eliminar 

Como al final de medio ciclo se apaga una luz roja, que se enciende en el comienzo del otro medio, podemos eliminar esas dos funciones. En principio igual se podría hacer al fin del loop y comienzo del nuevo loop, sin embargo, en el primer loop si hay que encender el led rojo, porque la primera vez viene apagado. Por ello En los siguientes ciclos encenderemos algo que ya está encendido, pero no pasa nada con ello.

He dejado estas líneas insertando “//” como comentario para que resalten. Realmente podríamos borrarlas, así el programa conseguiría un punto más de valoración, pues tendría menos líneas haciendo lo mismo, sin que se complique su compresión.

Generalmente el primer loop es especial 

Es muy frecuente que la primera vez haya que hacer cosas que en los siguientes loop ya no es necesario hacer, en muchos programas habrá que  saber dir ferenciar si se está ejecutando el primer loop o los sucesivos. Ya aprederemos a diferenciarlo. .

Poner a punto los programas complejos 

A mi, personalmente, me ha costado bastante poner a punto este programa, porque en su sencillez, tiene un juego de encendido y apagado de leds que es posible que inicialmente confunda mucho. La forma de poner a punto un programa y cualquier asunto en informática se basa en la vieja máxima de “Divide y vencerás”. Es decir, separar un problema un un conjunto de problemas más sencillos que puedan resolverse por separado y a su vez dividir estos problemas en otros aun mas sencillos, hasta que no veamos posible y sin complejidad resolver esos puntos independientemente de lo que tenga que hacer las otras partes. Lo importante para poner a punto un programa es ir poniendo a punto cada una de sus partes, poco a poco y no tratar de resolverlo del todo, sino cada parte por separado

En nuestro caso hemos hecho lo siguiente:

Análisis funcional

Generalmente si el enunciado del ejercicio esta bien redactado, en él debe quedar especificado en que condiciones ha de funcionar el programa, esto es en suma el Análisis Funcional. En nuestro caso fue le siguiente:

Para una maqueta deseamos simular un semáforo que regule el paso a través de un corto túnel que no permite el cruce de dos trenes. Para que evitar que un tren arranque mientras que el otro no ha terminado de pasar, antes de poner un semáforo en verde se dejara que pasen los dos semáforos en rojo, tanto si hay o no trenes en el interior del túnel.

Análisis Orgánico

Del estudio del Análisis Funcional se debe poder definir el Análisis Orgánico o que es lo que debe hacer nuestro programa para cumplir los requerimientos del Análisis Funcional. Aquí comienza el trabajo de dividir algo complejo en partes más sencillas.

En nuestro caso fue lo siguiente:

1º.- En un extremos se acaba de poner la luz en verde mientras que en el otro extremo está en rojo. Así se mantiene 25 segundos.

2º.- Para estimular el paso de los últimos coches, el verde se pone parpadeante cinco veces con periodos de encendido y apagados de un segundo. o sea esta así 10 segundos más, mientras que el otro extremo está en rojo

3º.- El semáforo se pone en rojo en un extremo, pero para dar tiempo a que salgan los coches que estuvieran dentro del túnel el otro extremo también continua en rojo durante otros 10 segundos

4º Se repite todo el proceso, pero en se cambian los extremos se pone en verde y rojo

De esto se deduce en lenguaje de semicódigo loa siguiente

  • 1º.- Circulación I >> D (IV) (ir) –- (dv) (DR) tiempo1
  • 2º.- Circonio I >> D (IV) parpadea 5 veces (tiempo2) resto no cambian
  • 3º.- No hay circulación (iv) (IR) –- (dv) (DR) tiempo3
  • 4º Se repite todo el proceso, pero en se cambian los extremos se pone en verde y rojo

Cambien se puede definir el Hardware que en neutro caso serán dos semáforo de dos led cada uno que necesitan cuatro pines digitales de salida para funcionar. Como se ve en el esquema que puse al principio.

Con todo esto, estamos en principio en condiciones de intentar iniciar programarlo. Por lo pronto ya tenemos el encabezamiento, un extracto del Análisis Orgánico, También podemos escribir el “Área de definición de variables y parámetros” y la Función “setup” pues se deduce en parte del Análisis Orgánico, (las diferentes valores de los tiempos) y del hardware que hemos diseñado, (los pin que se van a utilizar como OUPUT).

Todo provisional y dispuesto a cambios si algún paso posterior exige hacer un cambio en lo ya redactado. Pero cuando demos un paso más lo anterior debe funcionar perfectamente según lo previsto y no contener errores.

Lo más peligroso y lo que hemos de tratr de evitar

No nos puede pasar nada peor que dos o mas errores se solean a la vez, pues al tratar de corregir uno no apreciaremos arreglo y fácilmente tratemos de buscar la solucion volviendo a cambiar en ese punto con otra solución ,que tampoco puede arreglar nada, porque la solución pasa por arreglar también simultáneamente otro lado. Por ello es muy importante, que en la medidas de lo posible, los errores se produzcan sólo en lo que añadimos a la prueba, porque lo anterior lo dejamos funcionando correctamente.

Mantener solidarias las diferentes partes físicas del programa.

Observen primero de todo algo que es una tontería, pero facilita mucho la vida, sujeto la tarjeta Arduino a la “protoboard” con una anilla elástica de goma. Esto mantiene solidarias ambas tarjetas y evitan, que al manipularlas, se tire sin querer de los cables y se suelten. Por otra parte, al montar los circuitos se tiene las dos manos libres para manipular y resulta mas sencillo. En mi opinión siempre que sea factible conviene mantener solidarias por un sistema o por otro, la tarjeta y la protoboard, y en general todos los componentes que se utilicen. En programas con poca complicación basta utilizar anillas elásticas para hacer de todo un solo objeto.

.Eliminar los errores de montaje de Harware y los errores  ortográficos

tes que nada, conviene probar dos cosas,  si lo que hemos escrito del programa está bien escrito o tiene errores ortográficos, como unos de mayúsculas en lugar de minúsculas o faltas de “:” al final de lineas. Algo que nos indicará la compilación que detecta fácilmente este tipo de errores.

Por ello mada más terminar la función “loop” probaremos si puede compilarse. Cuando hayamos terminado de compilar y se cargue el programa en la Tarjeta no hará nada, porque todavía tenemos vacía la función “loop”, pero al menos habremos depurado algún error que otro. Y si el montaje que hemos realizado en la protoboard no contiene errores de montaje

Así pues escribiremos provisionalmente lo que podamos de la Cabecera, el Área de definición de variables y parámetros y la función setup, que al menos en parte se desprenden fácilmente del Análisis Orgánico y de el esquema del Hardware. A ello añadiremos la función “loop” en vacío para poder probar y compilar el programa.

/* Sketch E5.2 Simular de semáforo
* Izquierda (I), Derecha (D), Verde (V), Rojo (R )
* MAYUSCULAS = encendido, minúsculas = apagado
* 1º.- Circulación I >> D (IV) (ir) –- (dv) (DR) tiempo1
* 2º.- Circulación I >> D (IV) parpadea 5 veces (tiempo2) resto no cambian
* 3º.- No hay circulación (iv) (IR) –- (dv) (DR) tiempo3
* Se repite el proceso, pero en este caso es el otro extremo el que se pone en verde
* Repetir el ciclo
*/
// Área de definición de variables y parámetros ********************
int pindv = 10;
int pindr = 11;
int piniv = 12;
int pinir = 13;
int tiempo1 = 4000; // duración del 1º periodo
int tiempo2 = 400; // separación entre destellos cortos
int tiempo3 = 2000; // duración del 3º periodo
// Función setup ********************************************
void setup() {
// Pines abiertos como OUTPUT
pinMode(pindv, OUTPUT); // Pin 10
pinMode(pindr, OUTPUT); // Pin 11
pinMode(piniv, OUTPUT); // Pin 12
pinMode(pinir, OUTPUT); // Pin 13
}
// Función loop ********************************************
void loop() {
}

Probamos y compilamos esta parte y vamos detectando y corrigiendo los errores que hayamos cometido hasta que el programa se compile y se cargue en la tarjeta de Arduino. Con esto habremos resuelto muchos errores que aun siendo menores pueden dar muchos quebraderos de cabeza

Comprobar que hemos montado todo correctamente

Por otra partee teniendo compilado y cargado el programa ningún circuito de los que salen de los pines debe tener energía, pero podemos probar si los hemos montado bien dándoles energía con un cable provisional que salga de V5, así comprobaremos que el hardware esta bien montado (los leds “pinchados” en la dirección correcta, por ejemplo)

Vean en la primera foto un cable naranja que parte del pin 3V, (situado all lado izquierdo de la tarjeta), y que anda suelto.  Ese cable le iremos introduciendo sucesivamente en la misma fila donde mueren los cables que parten de los pines digitales,  (situados al lado derecho de la tarjeta).

P1050642.

Si hemos hecho el montaje de los componentes correctamente, (sobre todo si los leds se han conectado de la forma correcta, pataa larga hacia donde viene la corriente)  y conectan en los origicios de la “protoboard” previstos, de forma que los circuitos estén internamente conectados, lo que deba ocurrir cuando pase energía por el circuito ocurriraá (en este caso que se enciende el led)

P1050643

 

Uno por uno iremos probando todos los circuitos para cerciorarnos que funcionan según lo previst. Acabado esto ya podemos empezar a ir depurando el programa.

Iniciar el programa 

 

Ya estamos en condiciones de escribir el primer trozo del programa que en este caso es sumamente sencillo. encender una luz verde en un extremo y una roja en otro. Pese a todo conviene probarlo por separado del resto del programa. añadimos al programa entre los dos corchetes “,{…. ]“, las siguientes instrucciones

Primer módulo del programa  Encender el semáforo

// 1º.- Circulación I >> D (IV) (ir) –- (dv) (DR) tiempo1 ***************
digitalWrite(piniv, HIGH);
digitalWrite(pindr, HIGH);
delay(tiempo1);
// Apagamos las luces antes de iniciar un nuevo loop *******************
digitalWrite(piniv, LOW);
digitalWrite(pindr, LOW);
// Hacemos una pausa para tener tiempo de apreciar que se han apagado las luces
delay(1000);

Esto debe encienden un led verde en el extremo izquierdo y rojo en el derecho y al final del ciclo las volvemos a apagar pues se espera que el siguiente ciclo comience tal como salió de “setap”, con todo apagado, también añadimos una pausa al final de todo para poder diferenciar los diferentes loops y tener tiempo de asimilar si lo que ha pasado se corresponde con lo previsto.

Corregimos los errores que hubiéramos cometido y observamos que todo va bien pero los tiempos son muy largos para las pruebas, por lo que opto para reducirlos en el futuro a 4000 tiempo1 y 1000 la pausa final

Segundo módulo del programa Hacer parpadear la luz verde

Este punto lo haremos en dos veces, la primera hacerla parpadear una vez y la segunda copiando cuatro ves mas las mismas instrucciones.

A continuacion de encender las luces, añadimos primeramente  las instrucciones para que parpadee una vez, el final no hay que cambiarlo pues en este trozo no se encienden nuevoa leds. Como signe al final los mismos led encendidos no tenemos que cambiar el final-

// 2º.- Circonio I >> D (IV) parpadea 5 veces (tiempo2) resto no cambian ****
// 1º Vez ***************************************************
digitalWrite(piniv, LOW);
delay(tiempo2);
digitalWrite(piniv, HIGH);
delay(tiempo2);

Probado que funciona el parpadeo hacemos copy/paste de esas íines cuatro veces mas haciendo los cambios mímimos en los comentarios.

// 2º Vez ***************************************************
digitalWrite(piniv, LOW);
delay(tiempo2);
digitalWrite(piniv, HIGH);
delay(tiempo2);
// 3º Vez ***************************************************
digitalWrite(piniv, LOW);
delay(tiempo2);
digitalWrite(piniv, HIGH);
delay(tiempo2);
// 4º Vez ***************************************************
digitalWrite(piniv, LOW);
delay(tiempo2);
digitalWrite(piniv, HIGH);
delay(tiempo2);
//5º Vez ***************************************************
digitalWrite(piniv, LOW);
delay(tiempo2);
digitalWrite(piniv, HIGH);
delay(tiempo2);

Tercer módulo del programa Poner ambos extremos a rojo

Falta añadir tan solo la pausa donde los dos lads están en rojo, apagamos el estreno verde y le ponemos en rojo. Como en este nódulo si cambiamos las luces que quedan encendidas al final del loos cambiado los pins que apagamos al final pues dejar todo apagado como cuando empezó.

// * 3º.- No hay circulación (iv) (IR) –- (dv) (DR) tiempo3 ****************
digitalWrite(pindv, LOW);
digitalWrite(pindr, HIGH);
delay(tiempo3);
// Fin del paso en una dirección apagamos los semáforos que están encendidos
digitalWrite(pindr, LOW);
digitalWrite(pinir, LOW);
}

Módulo cuatro y siguientes, repetir lo mimo pero desde el otro extremo

Finalizado de poner a punto este módulo, hamos hecho todo lo reg fernte al paso de la circulacion de Izquierda a Derecha ahora hara que hacer lo mimo paraa que pase la circulacion de derecha a Izquierda. Observemos como está el programa hasta ahora

/* Sketch E5.2 Simular de semáforo
* Izquierda (I), Derecha (D), Verde (V), Rojo (R )
* MAYUSCULAS = encendido, minúsculas = apagado
* 1º.- Circulación I >> D (IV) (ir) –- (dv) (DR) tiempo1
* 2º.- Circonio I >> D (IV) parpadea 5 veces (tiempo2) resto no cambian
* 3º.- No hay circulación (iv) (IR) –- (dv) (DR) tiempo3
* Se repite el proceso, pero en este caso es el otro extremo el que se pone en verde
* Repetir el ciclo
*/
// Área de definición de variables y parámetros ********************
int pindv = 10;
int pindr = 11;
int piniv = 12;
int pinir = 13;
int tiempo1 = 4000; // duración del 1º periodo
int tiempo2 = 400; // separación entre destellos cortos
int tiempo3 = 2000; // duración del 3º periodo
// Función setup ********************************************
void setup() {
// Pines abiertos como OUTPUT
pinMode(pindv, OUTPUT); // Pin 10
pinMode(pindr, OUTPUT); // Pin 11
pinMode(piniv, OUTPUT); // Pin 12
pinMode(pinir, OUTPUT); // Pin 13
}
// Función loop ********************************************
void loop() {
// 1º.- Circulación I >> D (IV) (ir) –- (dv) (DR) tiempo1 ***************
digitalWrite(piniv, HIGH);
digitalWrite(pindr, HIGH);
delay(tiempo1);
// 2º.- Circonio I >> D (IV) parpadea 5 veces (tiempo2) resto no cambian ****
// 1º Vez ***************************************************
digitalWrite(piniv, LOW);
delay(tiempo2);
digitalWrite(piniv, HIGH);
delay(tiempo2);
// 2º Vez ***************************************************
digitalWrite(piniv, LOW);
delay(tiempo2);
digitalWrite(piniv, HIGH);
delay(tiempo2);
// 3º Vez ***************************************************
digitalWrite(piniv, LOW);
delay(tiempo2);
digitalWrite(piniv, HIGH);
delay(tiempo2);
// 4º Vez ***************************************************
digitalWrite(piniv, LOW);
delay(tiempo2);
digitalWrite(piniv, HIGH);
delay(tiempo2);
//5º Vez ***************************************************
digitalWrite(piniv, LOW);
delay(tiempo2);
digitalWrite(piniv, HIGH);
delay(tiempo2);
// * 3º.- No hay circulación (iv) (IR) –- (dv) (DR) tiempo3 ****************
digitalWrite(pindv, LOW);
digitalWrite(pinrv, LOW);
delay(tiempo3);
// Fin del paso en una dirección apagamos los semáforos que están encendidos
digitalWrite(piniv, LOW);
digitalWrite(pindr, LOW);
// Hacemos una pausa para tener tiempo de apreciar que se han apagado las luces
delay(1000);
}

Bata ahora hacer copy/pate de cada uno de los módulos cambiando izquierda por derecha es decir donde ponga “iv” poner “dv” y donde ponga “Ir” poner “Dr” y viceversa,

Habremos transformado la puesta a punto de un programa complejo, en la puesta a punto de una multitud de programas muy sencillos, cuya resolución y puesta a punto está al alcance de cualquiera.

Félix Maocho

 

indice

Anuncios

11 mayo 2016 - Posted by | Curso de Arduino, Robotica | , , ,

Aún no hay comentarios.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

A %d blogueros les gusta esto: