Felix Maocho

Para quien le interese lo que a nosotros nos interesa

Arduino – Formas de programar una lámpara con varios leds

Por Félix Maocho
7/10/2013

Objetivo del post

Observar que un mismo problema puede tener varias soluciones y que cada una de ellas suelen plantear ventajas e inconvenientes diferentes, por lo que debemos elegir la más adecuada a la solución de cada caso concreto,

Un segundo objetivo es repasar lo que son las interrupciones, la simulación de multitarea y las instalaciones Pull Up y Pull Down de los interruptores.

—————

Un consultante, aun más primerizo que yo, me ha hecho una consulta que voy a aprovechar para mostrar que en el mundo del software, siempre hay diversas caminos para llegar a un mismo resultado, pero unos caminos son ser más sencillos y eficientes que otras.

Generalmente la eficiencia se consigue utilizando elementos de hard más valiosos, y por tanto escasos, (memoria RAM, capacidad de almacenamiento etc.), por lo que habitualmente la mejor solución es la que utiliza en su trabajo el máximo de los medios de medios valiosos  a nuestra disposición, pero sin que su uso suponga penalizar otras cosas que queremos hacer a la vez, por ello frecuentemente tendremos que buscar soluciones menos óptimas, pero que castiguen menos el uso de medios de hard escasos.

Lo que desea resolver el comunicante, es cómo conseguir encender independientemente  dos pares de leds mediante dos pulsadores, de modo que cada pulsador encienda o apague un par de leds independientemente del los otros, en resumen que con el manejo de los dos pulsadores, podamos tener o todos los leds apagados  o encendidos un par u otro de leds o ambos a la vez.

Para entendernos. vamos a llamar a los pulsadores A y B y a los leds 1, 2, 3 y 4,  El botón A encenderá los leds 1 y 2 y el B los leds, 3 y 4. Como en Arduino UNO tenemos dos pines capaces de controlar interrupciones, la solución más sencilla y elegante, es controlar cada un de los pulsadores con uno de los pines capaces de detectar los cambios de tensión que se producen al pulsar el botón y aprovechar las funciones que lanzan con la interrupción, para encender y apagar según corresponda el par de leds que controla el botón que ha cambiado de estado.

Indudablemente es la solución más lógica, si Arduino no va a hacer otra cosa, pero hemos de tener en cuenta que haciéndolo así, hemos agotado un bien escaso de Arduino, el control de interrupciones y que si quisiéramos hacer algo más, no nos quedarían pins libres capaz de controlar interrupciones.

Por ejemplo, si quisiéramos hacer un vehículo robotizado con luces de posición y  luces largas, pero además quisiéramos que tuviera cualquier tipo de sensor de obstáculos,, habremos utilizado las interrupciones para encender y apagar luces y no tendríamos tan útil herramientas, para avisar que hay un obstáculo enfrente o que se está calentando en exceso el motor. Por ello voy a dar una soluciones al mismo problema, que no necesita del uso de este bien escaso.

Circuito eléctrico 100%

La primera solución es obvia y no necesita ni la tarjeta Arduino, en vez de poner pulsadores, ponemos interruptores de dos posiciones, (On/Off), iguales a las llaves de la luz que hay en todas las lámparas de una casa, y con ellos abriremos o cerramos dos circuitos diferentes, en el que hay situados dos leds en paralelo.

En este caso solo necesitaríamos una fuente que proporcionara 3,5 volt, para no quemar los leds y situar en paralelo en cada circuito dos leds, de modo que dando a un interruptor se encendieran un par de leds a la vez y dando al otro el otro par.

solucion sin arduino_bb

En el ejemplo que pongo, como no tengo fácil pintar los interruptores, directamente enchufo dos cables diferentes, de color verde y gris en ambos buses rojo y azul tanto del borde inferior como del superior el cable verde toma la energía del pin a 3,3 voltios de la placa Arduino, y a través de del cable gris se cierran el circuito desde los buses en un pin de tierra, (GND), de Arduino UNO.

Solo falta insertar en cada uno de los buses dos leds con la pata larga en el bus rojo y la corta en el azul. Para mas claridad he puesto dos leds rojos en los buses inferiores y dos blancos en los superiores. Es evidente, que si desconecto el cable verde que une el bus rojo inferior con la barra vertical de 5 orificios que se conecta al pin de Arduino que suministra 3,3 voltios, se apagaran los leds rojos y si desconecto el superior los blancos y si desconecto ambos no lucirá ninguno

Observen en el dibujo que no se ha utilizado ningún otro pin de Arduino aparte del que suministra voltaje a 3,3 voltios y el que proporciona la tierra (GND), Arduino en este caso solo actúa como mero reductor del voltaje de 5 voltios que envía  el PC por el cable USB a 3,3 volts, (igual que haría una resistencia de 230 Ώ),

Por tanto no hay que programar y compilar nada, Arduino en este caso no controla absolutamente nada solo hace de fuente de energía, Basta por tanto sustituir los cables que alimentan los buses rojos por interruptores de dos posiciones, (On/Off), para resolver el problema.

Circuito detector de interrupciones

Por supuesto, esta no es la solución que busca mi interlocutor, la pongo solamente para que observen, que a veces hay soluciones que no precisan de acudir a la electrónica, porque la electricidad clásica, con sus controladores mecánicos tradicionales, como interruptores, potenciómetro etc, solución el problema y a veces como en este, caso con más economía de medios por tanto más barato de construir el artefacto.

Vayamos ahora c la solución que pide el lector, utilizando dos pulsadores, es decir interruptores que solo cierran el circuito cuando se oprime el botón, como veremos la cosa se complica bastante.:

linterna de dos botones_bb

Los pulsadores les conectamos a los pines capaces de controlar interrupciones que son los pines 2 y 3. El pulsador A, lo conectamos al pin2 y el B al 3. Los colocamos en “Pull Up”, como se explicó en el capítulo 4 de Atelier JCM,  con el fin aprovechar la resistencia interna de Arduino.

Con este montaje el pin que controlará la interrupción esta a normalmente a 0 voltios y pasa a estar a cinco cuando se pulsa el botón que les conecta con tierra, (a través de una resistencia de 220 Ώ de seguridad para evitar cortocircuitos accidentales), y utilizamos la resistencia interna de Arduino cuando la tensión está a cero y nos ahorramos el uso de una resistencia de 1000Ώ, que garantice que el pin lee correctamente el voltaje cundo esta a 0V y no circula corriente.

Observen que al ser de OUPUT tanto los circuitos que parten de los pines 2 y 3 para el control de interrupciones como los pines 4 y 5, que alimentarán a los led, todos cierran en el pin de tierra (GND).

Cuando estos pines detecten un cambio de estado en su voltaje, en este caso el paso de HIGH a LOW, lo que indica  que hemos pulsado uno de los botones, disparan las rutinas de interrupción, tal como se explica en el post Arduino – Manejo de interrupciones que se encargaran de encender los leds, si están apagados, o apagarlos, si están encendidos. La rutina de interrupción del pin 2 controlará los leds blancos, alimentados por el pin 4 y la rutina de interrupción del pin 3 controlará los leds rojos alimentados por el pin 5.

Hemos pues pasado de una solución que no necesitaba la tarjeta Arduino, ni por tanto ningún tipo de programación, a una solución que necesita utilizar los dos únicos pines de Arduino capaces de detectar interrupciones y dos pines más para encender y apagar los leds más el programa de control adecuado y en la práctica hacer lo mismo que hacía el circuito anterior, con la sola diferencia de utilizar pulsadores en vez de interruptores de dos posiciones On/Off.

El hardware que hay que montar es tal como sigue, tanto los circuitos de los botones como los de los led van protegidos contra sobrecargas por resistencias de 220 Ώ.

Y el sketch que controla Arduino es el siguiente ;

/* Linterna de dos botones con la técnica de control de interrupciones */

// Pines que atienden interrupciones
int  intbla = 2, // El Pin 2 controla el botón que cambia los led blancos
int  introj = 3, // El Pin 3 controla el botón que cambia los led rojos

// Pin que encienden y apagan leds
int  ledbla = 4;  // enciende/apaga leds blancos
int  ledroj = 5;  // enciende/apaga leds rojos

// variables tipo volatile  que comunica la función de interrupción
// y el bucle principal (loop)
volátile int estbla = HIGH ;
volátile int estroj = HIGH ;

// Funcion Void que define el Hardware que utilizaremos
>void  setup () {

// Los pin de los botones se abren en modo OUPUT
pinMode (intbla, OUPUT) ;
pinMode (introj, OUPUT) ;
// Se activan las resistencias internas pull-up
digitalWrite (intbla, HIGH ) ;
digitalWrite (introj, HIGH ) ;
// definimos como OUPUT los pines que  manejan los led
pinMode (ledbla, OUTPUT ) ;
pinMode (ledroj, OUTPUT ) ;

// La interrupción  0 monitorea los cambios de estado del pin 2
// y lanza la funcion cambla para cambiar leds blancos
attachInterrupt(0, cambla0, CHANGE);
// La interrupción  1 monitorea los cambios de estado del pin 3
// y lanza la funcion camroj para cambiar leds rojos
attachInterrupt(1, camroj0, CHANGE);
} // fin de setup

// Funcion loop, solo crea unos segundfos de retardo<
void  loop () {
// No hacemos nada más que esperar unos segundos…
delay (2000);
} // fin del bucle

// la funcion de interrupcion cambla cambia leds blancos
// de apagado a encendido y viceversa
void  cambla ()   {  // Solo se ejecuta cuando hay un cambio de estado del Pin 2
// ver el estado de estbla y cambiarlo
if (estbla == HIGH) {
estbla = LOW
}
else {
estbla = HIGH
}
digitalWrite (ledbla, estbla)   / / encender o apagar los LED blancos
} / / fin cambla

// la funcion de interrupcion camroj cambia leds rojos
// de apagado a encendido y viceversa
void  camroj ()   {  // Solo se ejecuta cuando hay un cambio de estado del Pin 3
// ver el estado de estbla y cambiarlo
if (estroj == HIGH) {
estroj = LOW
}
else {
estroj = HIGH
}
digitalWrite (ledroj, estroj)   / / encender o apagar el LED rojos
} / / fin camroj

Circuito “multiproceso”

Por último si no queremos utilizar las interrupciones de Arduino, algo que estaría justificado si los dos únicos pines que pueden controlar interrupciones, se destinan a fines mas importantes, se puede simular un multiproceso a base de hacer un bucle muy rápido, que en su primera vuelta comprueba si se ha pulsado el botón A, en la siguiente vuelta el botón B y en la tercera actúa como corresponda de acuerdo con las pulsaciones detectadas.

Si no se ha pulsado ningún botón, esta tercera vuelta no hará nada dejando todo como estaba y si se ha pulsado uno, o los dos botones, cambia el estado de los leds correspondientes, es decir los apagan, si estaban encendidos, o los encienden si estaban apagados.

En este caso y para que sirva de repaso montaremos los pulsadores según el esquema Pull Down, a diferencia del caso anterior en esta postura los pines que controlan el estado de los pulsadores son de INPUT (entrada) y están normalmente a 0 Volts (LOW) y cuando se pulsa el botón pasan a HIGH, este montaje tiene el inconveniente de que se precisan de un montaje algo más complejo, que incluye dos resistencias adicionales de 1000 Ώ  conectada a tierra para que el pin detecte con seguridad el voltaje 0 cuando m no se pulsan los interruptores.

Pues si el pin no estuviera conectado a tierra, podría actuar como condensador de corrientes parásitas internas de Arduino por lo que el control de voltaje podría ser errático, al estar conectado a tierra con una resistencia muy grande aseguramos que por el no pasa ninguna corriente, o sea está a 0 voltios. Observe las dos diferentes formas de montar un pulsador comparando este esquema con el anterior.

Recalco que la elección de este montaje en “Pull Down” es solo para tener un ejemplo en el repaso de las diferentes formas de montar un pulsador, pero no es condición necesaria de este circuito, que funcionaría perfectamente igual de bien habiendo montado los pulsadores en los pines 4 y 5 pero en “Pull Up” como hicimos e el caso anterior.

En este caso los pines que van a encender y apagar los pines son de OUTPUT y han de acabar en el pin de tierra (GND) y los que controlan los botones de INPUT es decir reciben energía cuando se oprimen los botones  para ello, por tanto los circuitos han de iniciarse en pin de 5V.

Los pines de control de interrupciones se encuentran normalmente en LOW pues son de INPUT y están unidos a tierra, (a través de una resistencia de 1000 Ώ que garantiza que está a 0V) . Cuando se oprime el botón les llega la corriente procedente del pin 5V (protegida contra cortocircuitos  por las pequeñas resistencias de 220 Ώ ), la energía que se escapa hacia tierra (GND) es mínima porque ahí tenemos colocado el “tapón” de la resistencia de 1000Ώ, por lo que se mantiene la tensión que llega al pin por lo que se detecta el cambio a HIGH.

linterna multiproceso_bb

Las resistencias verticales que están al lado de los botones deberán ser de 1000 o mas homios, el resto de las resistencias son las habituales de protección contra cortocircuitos de 220 Ώ

Así pues el sketch que gestione el “multiproceso” será como el que sigue, que es una modificación del sketch que escribí en el post “Arduino – Programar multitareas, controlar una intermitencia y simultáneamente vigilar la pulsación de un botón” 

/* Linterna de dos botones con la técnica multiproceso */
// Area de definición de constantes y variables

// Control del bucle
int privue = 1 ;    // Controla la primera vuelta 1 = 1ª vuelta 2= otras vueltas
int numcicl = 1 ;       // Controla el ciclo que recorremos  valores posibles 1, 2 y 3

// Control de los pulsadores y estado de los led
int pulbot = 0  ;    // Controla si se pulsa algun boton Valores 0=no 1=si
int pulbota = 0  ; // Controla si se pulsa el botón A Valores 0=no 1=si
int pulbotb = 0  ; // Controla si se pulsa el botón B Valores 0=no 1=si
int encbla = 0 ;    // Estado de los led blancos 0=apagados 1 = encendidos
int encroj = 0 ;    // Estado de los led rojos 0=apagados 1 = encendidos
int butstata = 0; // variable para leer el estado del pulsador A
int butstatb = 0; // variable para leer el estado del pulsador A
// Pines que se utilizan en el aparato
int pinledb = 4 ;  //  Pin para el manejo de leds blancos
int pinledr = 5 ;  //  Pin para el manejo de leds blancos
int pinbot1 = 6 ;  //  Pin control del boton 1 que enciende leds blancos
int pinbotr = 7 ;  //  Pin control del boton 2 que enciende leds rojos

// Funcion Setup Declaración del Hardware utilizado
void setup() {
pinMode(pinledb, OUTPUT);
pinMode(pinledr, OUTPUT);
pinMode(pinbot1, INPUT);
pinMode(pinbot2, INPUT);
} // Fin de la funcion setup

// Loop donde se ejecuta el proceso
void loop(){

// Solo la primera vuelta vamos a apagar inicialmente los dos pares de leds
if (privue == 1) {

digitalWrite(pinledb, LOW);  // apagamos los led blancos
digitalWrite(pinledr, LOW);   // apagamos los led rojos
encbla = 0 ;    // Estado de los led blancos 0=apagados
encroj = 0 ;    // Estado de los led rojos 0=apagados
privue = 2 ;    // Indicador de 1 vuelta a 2 para que nunca pase por aquí

}  // fin de los trabajos a hacer la primera vez

// Ciclo 1 .-  comprueba si se ha pulsado el boton a
if (numcicl == 1) {

butstata = digitalRead(pinbot1); // leer y guardar el valor obtenido en “butstata”
if (butstata == HIGH) { // si se ha pulsado el boton a
pulbota = 1; // poner pulsado a 1

}  // fin del ciclo 1

// Ciclo 2 .-  comprueba si se ha pulsado el boton b
if (numcicl == 2) { // ejecutar ciclo 2 chequear boton b

butstatb = digitalRead(pinbot2); // leer y guardar el valor obtenido en “butstatb”
if (butstatb == HIGH) { // si se ha pulsado el boton b
pulbotb = 2; // poner pulsado b 1

} // fin del ciclo 2

// Ciclo 3 .-  Cambiar las luces según manden los indicadores de los botones
if (numcicl == 3) { // ejecutar ciclo 3 cambiar leds según indiquen las pulsaciones

if (pulbota == 1) {  //  encender o apagar los leds blancos

if  (encbla == 0) {  //  leds blancos apagados – encenderlos

digitalWrite(pinledb, HIGH) ;  // encendidos los leds blancos
encbla = 1 ; // Indicador de Leds blancos encendido

}

if  (encbla == 1) {  //  leds blancos encendidos – apagarlos

digitalWrite(pinledb, LOW) ;  // apagados los leds blancos
encbla = 0 ; // Indicador de Leds blancos apagados

}

delay (2000) ; // damos dos segundos para dar tiempo a retirar
// el dedo del boton después de encender/apagar las luces
pulbota = 0 ; // dejamos el indicador de pulsado el boton a preparado para otra vez
} //  Fn de encender o apagar luces blancas

if (pulbotb == 1) {  //  encender o apagar los leds rojs

if  (encroj == 0) {  //  leds rojos apagados – encenderlos

digitalWrite(pinledr, HIGH) ;  // encendidos los leds rojos
encroj = 1 ; // Indicador de Leds rojos encendido

}

if  (encroj == 1) {  //  leds rojos encendidos – apagarlos

digitalWrite(pinledr, LOW) ;  // apagados los leds rojos
encroj = 0 ; // Indicador de Leds rojos apagados

}

delay (2000) ; // damos dos segundos para dar tiempo a retirar
// el dedo del boton después de encender/apagar las luces
pulbotb = 0 ; // dejamos el indicador de pulsado el boton b preparado para otra vez

} //  Fn de encender o apagar luces blancas

} //fin del ciclo 3

// para hacer en todos los ciclos
numcicl = numcicl +1 ;  // Sumanos 1 al numero del ciclo
if(numcicl == 4) { // Si llega a cuatro le ponemos el valor 1

numcicl = 1 ;

} // fin del loop

Como se observa en este caso se utilizan igualmente cuatro pines de Arduino pero se dejan libres los pines 2 y 3 especializados en interrupciones que se pueden utilizar para otra cosa.

El único problema es que se recurre al artificio de para un momento la ejecución del programa para dar tiempo a retirar el dedo, Si se mantiene el dedo sobre un botón más de dos segundos, o se pulsa dos veces, pero tan seguido que no han transcurrido los dos segundos de parada, la máquina entenderá erróneamente las pulsaciones, lo que no ocurre si se utilizan las interrupciones, pues estas solo le lanzan cuando cambia el estado del pin, independientemente de cuanto tiempo haya estado el pin libre o pulsado continuadamente.

Por supuesto para una linterna el problema no es demasiado importante pues si las luces no responden o lo hacen defectuosamente, el usuario de la máquina repetirá la pulsación, pero hay procesos en que el no detectar la pulsación o interpretarla erróneamente es crítico, imaginemos que no son luces de colores lo que controlamos sino el freno y acelerador de un robot, en este caso deberemos optar por seguridad por la anterior solución pues una mala interpretación puede dar lugar a errores irreparables.

Por último cabria buscar una solución basada en un solo botón que hiciera la siguiente cosa:

  • Primera pulsación .- Encender leds rojos
  • Segunda pulsación .- Apagar leds rojos y encender los k leds blancos
  • Tercera pulsación  .-  Encender los cuatro leds
  • Cuarta pulsación  – Apagar los cuatro leds

Bastaría en este caso llevar un contador de pulsaciones que pudiera tomar circularmente los valores 0,1,2,3, y 4 y dividir el loop, o la función de interrupción en cinco trozos, según nos decidiéramos por utilizar un pin de interrupciones o un pin normal,

En ambos caso el esquema consistiría en primeramente estudiar si se ha pulsado el botón y en los siguientes hacer lo que corresponda según el estado que adquiera el contador de pulsaciones. Vemos que aquí solo utilizamos un pulsador y en su caso uno solo o sea el 50% de los pines capaces de identificar pulsaciones,

Como vemos, cuando nos enfrentamos a un problema, hay normalmente diversas soluciones por lo que deberemos primeramente explorar cuales de ellas se nos ocurren y como todas tienen ventajas e inconvenientes, elegir aquella que en nuestro caso balanceé mejor las ventajas e inconvenientes.

Félix Maocho

Capítulos de Arduino relacionados con este post

 

 

 

About these ads

7 octubre 2013 - Posted by | Robotica | , , ,

14 comentarios »

  1. lo de los led esta mui bien .pero tienes interructores, de dos posiciones comutados dobles ,rotativos de barias posiciones que podrianvaler ygual que lo que as comentado . PERDONAR PUES SOY NUEVO EN LO DE EL ORDENADOR majuvioç, gracias.

    Comentario por majuvio | 8 octubre 2013 | Responder

    • Ciertamente hay muchas formas de hacer una lampara o linterna con varias luces y una de las soluciones y ademas sencilla, es la que indicas, insertar un conmutador de varias posiciones.

      Seria un camino más para obtener el mismo objeto, poder encender o apagar las luces independientmente. Por supuesto, yo he indicado tres caminos diferente y he comentado superficialmente la existencia de otro, pero ni mucho menos he pretendido agotar todas las posibles soluciones al problema.

      Comentario por felixmaocho | 8 octubre 2013 | Responder

  2. Hola, lo primero la enhorabuena por sus ensayos y enseñanzas con arduino.
    Al leer su post me surgio la duda y quisiera preguntarle como se haria con solo los led blancos y con un conmutador para apagar y encender en pwm, es decir poniendo el conmutador en dos pines y el central a masa, segun estubiera en una posicion encendiera en pwm en unos 5 segundos y al cambiarlo a la otra se apagara en otros 5 segundos en pwm¿¿Esto se podria hacer?? Otra cuestion que al apagarse se quedara un poquito encendida, esto ¿¿se podria hacer???
    Estoy pensando en comprarme un arduino uno o mega, si esto que le expongo se pudiera hacer. Un saludo y muchas gracias.

    Comentario por Luiyi | 16 febrero 2014 | Responder

    • Tendría que ver el esquema del circuito circuito, pero en principio, veo posible alimentar alternativamente un ledm a partir de dos Pin diferentes (independintemente que sean del tipo PWM o normales), lo que yo haría por si acaso o insertar en cada una de las ramas que salen de los pin un diodo. que actuara como valvla para impedir el retroceso de la corriente, de modo que impidiera que la energía que sale un pin se desvíe intentando entrar por el otro pin. Con esta medida no veo dificultad para encender un led alternativamente por los dos pines.

      Lo que no veo claro es por qué lo quiere hacer, pues una unica salida PWM permite aumentar y disminuir la intensidad del diodo alimentado con un solo pin, con solo aumentar y diminuir periódicamente (con valores entre 0 y 255), el parámetro valor de una instrucción
      “analogWrite (pin, valor)”,
      Por ejemplo en cada ciclo, podemos ir modificando “valor” sumando cierta cantidad en cada vuelta a hasta llegar a 255 y a partir de ahim ir reduciendo el valor en cada loop. Con ello el led aumentará y disminuirá de intensidad.

      Estudie el menjo de la instruccion “analogwrite” aqui http://arduino.cc/es/Reference/analogWrite#.UwIAsfl5N3k

      Saludos y si no lo ve claro vuelvame a hacer una consulta con un comentario. Suerte

      Comentario por felixmaocho | 17 febrero 2014 | Responder

      • Hola de nuevo, si me queda claro, pero lo buscaba en digital, no analogico y lo del diodo de cierre de retroceso no haria falta, ademas la orden seria
        void loop(){
        if (digitalRead(inputPin1) == HIGH) {
        digitalWrite(ledPin, HIGH);
        }
        else if (digitalRead(inputPin2) == HIGH) {
        digitalWrite(ledPin, LOW);
        }
        }

        Un saludo

        Comentario por Luiyi | 17 febrero 2014

      • Creo que tienes un pequeño error. `falta poner en la funcion If el pin1 o pin2 que quiers encender o apagar. supongo que quieres decie si esta encendido el pin1 enciende el pin2 y si esta encendido el pin2 apaga el pin1, pero no veo claro que eso funcione porque me faltan las alternativas que digan si esta apagado, enciende

        yo escribiria una cosa asi:

        void loop(){
        if (digitalRead(inputPin1) == HIGH) {
        digitalWrite(ledPin1, LOW);
        digitalWrite(ledPin2, HIGH);
        }
        Else
        else ¨{
        digitalWrite(ledPin2, LOW);
        digitalWrite(ledPin1, HIGH);
        digitalWrite(ledPin, LOW
        }
        }

        Pero independientemente Vuelvo a decirte que no veo el objeto de lo que intentas. pues el Led aparentemente siempre estará encendid,o (lo deja estar una fracción de segundo). y no veo la ventaja de que lo alimentes con un pin o con otro alternativamente, o que simplemente lo alimentes con uno con uno lo apagues un instante e inmediatemente lo vuelvas a encender por el mismo pin.

        Suponte que escribo

        void loop(){
        digitalWrite(ledPin1, HIGH);
        digitalWrite(ledPin1, LOW);
        digitalWrite(ledPin2, HIGH);
        digitalWrite(ledPin2, LOW);
        }

        Hago lo que tu pretendes alimenta el Led con dos pines, de forma más sencilla, pero si en vez de Pin2 pusiera Pin1 en las dos últimas sentencias, no notariamos diferencia en el Led y lo habrias conseguido c utilizando un solo pin

        Lo que si aseguro es que en efecto es posible, alimentar un led desde dos PIN alternativos, sigo pensando que más seguro es poner unos diodos que evite que el voltje de un pin entre por el otro pin, pero puede que no sea necesario.

        Comentario por felixmaocho | 19 febrero 2014

      • Hola felix, una vez mas un tutorial perfecto para aprender de los mejores. Te vuelvo a preguntar de nuevo, teniendo dos interruptores, pulsadores o conmutadores(a y b), se podria hacer que al presionar uno (a) se encendieran los led progresivamente en 10-15 segundos, permanecieran asi al maximo y al presionar el otro (b) se apagaran progresivamente en 10 segundos?????
        Otra pregunta: se podria hacer que presionando (a) se encendieran de golpe, al presionarlo de nuevo, esperarar 5 segundos y luego se apagaran progresivo durante 10 segundos?????
        Es algo pensado para controlar en una guarderia de niños (orfanato) la hora de la siesta. Un saludo

        Comentario por Luiyi | 25 febrero 2014

      • Te contesto. Es posible, pero tiene un problema que no se bien como solucionar, es relativamente fácil hacer encender progresivamente un led conectándolo a un pin analógico del tipo PWM o ” ~ “, que producen una rápida onda de secuencias de encendidos y apagados sucesivos, que se puede regular u intensidad, con lo que hacen que el led reciba menos energía y luzca por ello débilmente en proporción a la intensidad de la onda por tanto basta regular que durante un tiempo discreto luzca con intensidades cada vez más crecientes o decrecientes luz. Para controlar la interrupción puedes conectar el botón a pines que controlan interrupciones o utilizar la técnica de simulación de “multiproceso”, un procedo para averiguar i han dado al interruptor y otro proceso para hacer lo indicado con el botón.

        Pero el problema que te vas a encontrar, es que necesitaras para manejar una corriente de 220 voltios, que supongo que es la que tienes en el orfanato, necesitas un relé y mucho me temo que el relé no rebaje el voltaje de forma proporcional a como manda e la salida PWM, (yo no lo he estudiado y a lo mejor es posible)

        Si no funcionara el relé para regular el voltaje, tendrías que utilizar un potenciómetro que redujera el voltaje de la red, con el fin de reducir su intensidad y que estas bombillas fueran sensibles al voltaje como por ejemplo lo son las de incandescencia tradicional o las halógenas, el potenciómetro se podría manejar con un motor paso a paso o un servomotor, con lo que la cosa se complica no tanto electrónicamente sino más bien mecánicamente.

        Yo para esta solución, utilizaría unos potenciómetros que se introducen en la caja de los interruptores sustituyendo a los interruptores normales, que si colocan sin problema y hacen precisamente lo que tu quieres y no son caros. Te dejo una publicidad de uno que hace Philipis , pero los hay de muchas marcas, los encuentras en ferreterías un poco el especializadas en electricidad o en Leroy Merlin Saludos http://www.lighting.philips.es/application_areas/lighting_control/indoor_potenciometros.wpd

        Comentario por felixmaocho | 26 febrero 2014

      • Hola Felix, primero no trabajo ni vivo en ella, vivo en frente, y son tiras led lo que le hemos regalado para que lo pongan para los crios, tengo un sketch, si sabes programacion y quieres te lo paso por email y me dices si funcionaria, que sobra o hace falta. Porque vamos a regalarles los arduino para ello. Un saludo

        Comentario por Luiyi | 28 febrero 2014

      • Con tiras de leds si puede funcionar manejada con un arduino UNO. Mandamé el sketch en un comentario y un esquemit de como los vas a conectar si crees que es necesario explicarlo un poco más. Saludos

        Comentario por felixmaocho | 28 febrero 2014

      • Felix sino te importa prefiero mandartelo al email todo. El mio creo lo tienes ya. Un saludo

        Comentario por Luiyi | 28 febrero 2014

      • mi mail es fmaocho@gmail.com y en efecto tengo el tuyo Saludos.

        Comentario por felixmaocho | 28 febrero 2014

  3. Hola Felix, leyendo cada post en los que explicas el manejo de las interrupciones, me surge la duda en el aumento y disminución de intensidad de un led, es posible hacerlo mediante las interrupciones solamente??? o tendría que hacer uso de PWM? , me interesaría saber como hacerlo con las interrupciones, si es posible y poderle dar ordenes alternativas, es decir, durante el proceso de aumento de intensidad en el punto que se tenga si entra otra interrupción se encienda o apague en su totalidad, sería posible??. Espero haberme explicado y me puedas asesorar.
    Muchas gracias!!!

    Comentario por asoany | 10 junio 2014 | Responder

    • Primera cosa no se exactamente a que te refieres con las interrupciones pues normalmente en Arduino manejo de interrupciones, se suelen referir a como actuar ante un hecho previsto pero que no se sabe cuando va a ocurrir, por ejemplo cuando el sensor de un robot detecta un obstaculo en su trayectoria. Algo que exolica un poco en este post. http://felixmaocho.wordpress.com/2013/08/05/arduino-manejo-de-interrupciones/

      Sin embargo dentro del contexto al que te refieres creo mas bien que te refieres a cortar el paso de energía es decir a “interrupciones eléctricas” es decir encender y apagar luces y en tu caso más concreto como contolar la intensidad de las luces.
      la forma mas sencilla de modificar la intensidad de la luz en un led es utilizar de salida un pin que soporte PWM, (los pin digitales marcados con el signo ~ ) y utilizar el mandato:

      analogWreite (pin,intensidad) donde “pin” es lógicamente el pin digital PWM que utilizas e intensidad un valor entre 0 y 255 = correponde a apagado y 255 a la máxima intensidad. si quieres aumentar poco a poco la intensidad basta que lo metras en un proceso como puede ser este:

      for (int i=0, i<256, i++)
      {
      analogWreite (pin,i);
      delay(xmilesimas);
      }

      Y para apagar poco a poco

      for (int i=0, i256, j++
      }
      for (int i=0, i<veces, i++)
      {
      digitalWrite(pin, HIGH);
      delay(retardo*(xmilesimas+j));
      digitalWrite(pin, LOW);
      delay(retardo*aymilesimas);
      }
      }

      En este caso a medida que aumenta j el pulso de encendido dura más y el de apagado es constante por lo que llega más energia por sgundo al LED y el efecto es que luce más intenso ( sies suficientemente rápido el encendido y apagado, si no la veremos parpadear). Basta que en el sketch juegues con los valores de "retardo", "xmilesimas" y "ymilesimas" para que tarde mas o menos en aumentar la luz antes de llegar al máximo, aunque debes entender que la duración de la luz encendida depende de la suma de los delay y tendras que hacer alguna prueba hasta ajustar lo que quieres que tarde y quizá entonces se vea el parpadeo por lo que tendrás que aumentar en un mismo ciclos de encendido y apagado cosa que puedes conseguir con otro bucle for o simplemente si es poco copiando varias veces las lineas de, encender. delay, apagar, delay.

      Calculo que además habrá otras muchas formas de hacerlo, estas son las que se me ocurren a mi así a vuela pluma y ojo no las he probado. Como siempre ocurre el hacer las cosas a pelo permite un control más fino, pero es más complejo de poner a punto. Por eso, de no existir algún impedimento, la que más me convence en este momento de mi conocimiento de Arduino, (no excesivo), es utilizar un pin PWM

      Saludos

      Comentario por felixmaocho | 10 junio 2014 | Responder


Deja un comentario

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

Seguir

Recibe cada nueva publicación en tu buzón de correo electrónico.

Únete a otros 393 seguidores

%d personas les gusta esto: