bclose

Condicionales y botones

La instruccion if

Objetivos

.

 
    • Lógica digital y algebra de Bool.
    • Los condicionales.Instrucción if.
    • Botones, pulsadores y pullups.
    • Debouncing.

 

Material requerido.

ArduinoUNO  Arduino Uno o similar. Un PC con el entorno de Arduino correctamente instalado y configurado.
Img_3_4 Una Protoboard.
componente Un diodo LED.
Img_5_1  Un pulsador.
 Img_3_5  Dos resistencias de 330 Ohmio.
Img_3_6 Algunos cables de Protoboard..
tienda online prometec

Lógica digital y algebra de Bool

.

En la sesión anterior presentamos el tipo de variable bool destacando que solo puede tomar dos valores: True o False. Aunque para quienes no estén acostumbrados al algebra booleana o binaria puede parecer excesivo dedicar un tipo a algo tan simple, en la práctica buena parte de las instrucciones de programación se apoyan o dependen de este tipo de variables.

La razón práctica es que con frecuencia hay que tomar decisiones para seguir un camino u otro en función de que se cumpla una condición dada; Esta condición se debe evaluar necesariamente,  a True o False para tomar una decisión sin duda posible.

Por ejemplo, en las sesión 4 usamos la instrucción for  y comentamos que la iteración se mantiene mientras se cumpla una cierta condición. Esta condición debe ser evaluable a True o False, es decir es un booleano.

Existen otras muchas instrucciones que se apoyan en los valores booleanos, (como los condicionales if que veremos en esta sesión)  pero en un modo muy explicito toda la computación actual se basa en la lógica digital de solo dos valores que solemos llamar 1 y 0, pero que con todo derecho podemos llamar a estos valores True y False.

Los ordenadores modernos funcionan mediante la aplicación del algebra de bool a variables booleanas y con un juego completo de operadores lógicos como la negación, que vimos en la sesión anterior, mas operadores lógicos como AND, OR, + y – .

 

La instrucción if

 

En este capítulo vamos a presentar unas instrucciones nuevas de C++, que nos permitan tomar decisiones para hacer una cosa u otra.

La instrucción if es muy sencilla de usar, basta con pasarle entre paréntesis una variable o condición que se evalúe a true o false. Si el resultado es true se hace el bloque que viene a continuación y en caso contrario se ejecuta el bloque que hay detrás del else si existe.

Si no existe la clausula del esle, entonces el bloque que sigue al if, se ejecuta o no, en función de la condición y luego sigue con la secuencia de instrucciones a continuación.

     if ( condición)
          {   
              instrucción 1 ;
              instrucción 2 ;
              ................
          }
     else 
         {
              instruccion20 ;
              instruccion21 ;
              ..............
 }

Recordemos que en el circuito de la sesión anterior disponíamos de un pulsador y de un LED, en esta sesión vamos a continuar con el mismo circuito y para conseguir que el LED se encienda o apague al pulsar el botón. Para ello podríamos mantener  la misma función setup() y escribir el loop() diferente:

     void loop()
          {
              bool valor = digitalRead(boton) ;
              if ( valor)
                   digitalWrite( LED, HIGH) ;
              else
                   digitalWrite( LED, LOW) ; 
           }

Leemos primero el botón a una variable bool y después decidimos si encender o apagar el LED dependiendo de qué su valor sea True o False.

 
  • Recordemos que un bloque es un conjunto de instrucciones encerrados entre llaves y que hay un caso particular en el que se pueden omitir si y solo si, el bloque consta de una única instrucción como es nuestro caso.
  • Se puede utilizar una instrucción if omitiendo la cláusula de else si se desea, pues esta es opcional.
 

Volviendo con los botones

 

Vamos con un programa diferente. Queremos que el botón actúe como un interruptor, que al pulsarlo una vez se encienda, y la próxima vez lo apague. Podríamos plantear algo así y os recomiendo que lo probéis en vuestro Arduino:

     int LED = 10 ; int boton = 6 ;
     bool estado = false ;
     void setup()
          {
             pinMode( LED, OUTPUT) ;
             pinMode( boton , INPUT_PULLUP) ;
             digitalWrite(LED , LOW) ; // Apagamos el LED al empezar
          }
     void loop()
          { 
              bool  valor =  digitalRead(boton) ;                 //leemos el botón: false  =  LOW
              if ( valor == false )                               // esto es que han pulsado el botón
                   {
                        estado = ! estado ;                       // cambiamos el estado
                        digitalWrite(LED, estado) ;            // escribimos el nuevo valor
                   }
          }

La idea es definir una variable llamada estado al principio para guardar la situación del LED. El loop comprueba si se ha pulsado el botón, y de ser así invierte su estado,  y después escribe el valor de estado en el LED. Si estaba encendido lo apaga. Si estaba apagado se enciende.

Aunque parece un plan perfecto, en la práctica no va a funcionar. En el tiempo que nosotros tardamos entre pulsar y liberar el botón, nuestro humilde Arduino es capaz de leer unos cuantos miles de veces el pulsador e invertir el valor del LED otras tantas.

Por eso, si lee un número par de veces dejara el LED como estaba y si lo lee un número impar de veces lo invertirá. En la práctica la situación del LED se torna aleatoria, y si pulsáis repetidamente el botón veréis que el resultado es impredecible.

Otra fuente de problemas es que en el mundo real un interruptor no cambia de un estado a otro de forma perfecta, sino que suele rebotar y causar varios conexiones y desconexiones muy rápidas antes de quedar en un valor estable. A esto se le llaman rebotes (bouncing) y al procedimiento para eliminar estos rebotes se le llama debouncing en la jerga electrónica.

El debouncing se puede hacer por hardware con un conjunto de resistencia y condensador, o por software, mucho más frecuentemente (por más barato) y para esto una solución es nuevamente frenar a Arduino y hacerle esperar un tiempo entre 50 y 250 mili-segundos una vez que detecta que se ha pulsado el botón, de modo que nos dé tiempo a liberar el pulsador:

     void loop()
           {          
               bool  valor =  digitalRead(boton) ;                 //leemos el botón: false = LOW
              if ( valor == false )                               // esto es que han pulsado el botón
                  {
                      estado = ! estado ;                        // cambiamos el estado
                      digitalWrite(LED, estado) ;            // escribimos el nuevo valor
                      delay(250) ;
                  }
            }
 
  • Muy importante: Nótese que la condición es (valor == false), con doble = . En C++ la comparación de dos valores usa ==, la asignación de valor a una variable solo uno. Esto es fuente de errores frecuentes al principio (entre novicios inexpertos).
 

Este lapso de 250 ms es suficiente para pulsar y liberar el botón cómodamente. Si probáis esta variante veréis que ahora el LED invierte su valor cada vez que pulsas, siempre y cuando no te demores demasiado en liberar el botón.

Pero… ¿Qué pasa cuando dejas el botón pulsado?

Pues sencillamente que el LED invierte su estado cada 250 ms (milisegundos) y tenemos otra variante del blinking LED.

Si queremos poder mantener pulsado sin que se produzca este efecto hay que sofisticar un poco más el programa:

     int LED = 10 ; int boton = 6 ;
     bool estado = true ;
     bool estado_anterior = true ;

     void setup()
          { 
               pinMode(boton, INPUT_PULLUP);        //Hemos eliminado R3 
               pinMode(LED, OUTPUT);
          }

     void loop()
          {
               estado = digitalRead(boton);
               if (estado != estado_anterior)      //hay cambio : Han pulsado o soltado
                  {
                     if (estado == LOW)            //Al pulsar botón cambiar LED, pero no al soltar
                           digitalWrite(LED, !digitalRead(LED));
                     estado_anterior = estado ;     // Para recordar el ultimo valor
                  }
           }

Ya dijimos que para comprobar si dos valores son iguales usamos ==, Para comprobar si son diferentes usamos != , y existen otros operadores relacionales

 
  • Igual que: ==
  • Distinto de: !=
  • Mayor que: >
  • Mayor o igual: >=
  • Menor que: <
  • Menor o igual: <=
 

Vale la pena comentar aquí que, a pesar de su aparente inocencia, los botones tienen una sorprendente habilidad para complicarnos la vida, y que en la práctica la combinación de rebotes y la necesidad de corregirlos, junto al uso de pullups que garanticen la correcta lectura, pueden hacer que su uso se pueda complicar mucho más de lo que parece, sino se estudia el problema con calma.

Por último, una condición lógica se puede construir mediante los operadores lógicos AND, OR, y NOT cuyos símbolos son respectivamente: &&, || y !

Si usáramos un circuito dos pulsadores con pullups (True, si no se pulsa) y un LED, dependiendo del comportamiento que se busque podemos especificar diferentes condiciones:

 
  • If ( boton1 && boton2) Que ambos botones estén sin pulsar
  • If ( !( boton1 && boton2)) Que ambos estén pulsados.
  • If( boton1 || boton2 ) Que al menos uno este sin pulsar, o ambos.
 

Resumen de la sesión

.

 
    • Hemos visto la instrucción if / else.
    • Vimos varios programas con pulsadores y como hacer el debouncing.
    • Hemos presentado los operadores lógicos de relación y comparación.
    • Continuamos escribiendo pequeños programas para desarrollar la forma de pensar necesaria para escribir nuestras propias aplicaciones.

 

 

 

 

(110) Comments

    • Antonio

    Hola
    Nesesito ayuda
    Quiero prender un led presionando (n) veces el push button.

    • Hola Antonio, mete dentro del primer condicional un contador, es decir una variable en la que sumes 1 cada vez que hayas pulsado el botón. Y dentro de ese condicional mete otro anidado en el que compares la variable con el número de pulsaciones que buscas. Cuando se cumpla enciende el LED y pon a 0 la variable. Un saludo.

  • hola, tengo un pequeño código para intentar hacer funcionar o empezar el estado de lectura de un sensor PIR. Lo que quiero hacer con esto es que si el botón esta en Alto, se coloca el digitalRead del sensor pero cuando presiono el botón es como si el sensor no detectara nada
    Nota: uso 2 leds uno para saber que el botón esta en alto y otro para saber si el sensor esta en alto también (el led del sensor nunca prende).

    int estado =0; //guarda el estado del boton 
    int salida =0; // 0 = LED apagado / 1 = LED prendido
    int estadoant =0;

    void setup() {
    pinMode(2, INPUT); //boton Simple
    pinMode(3, OUTPUT); //LED del Boton (indica que el boton funciona)
    pinMode(5,OUTPUT); //LED del PIR (indica que el PIR detecta)
    pinMode(4,INPUT); //PIR
    }

    void loop() {

    estado = digitalRead(2);

    if ((estado ==HIGH) && (estadoant ==LOW)) { //condicional para el boton precionado leido

    digitalRead(4);

    salida = 1 – salida;

    delay(10);

    if (4 ==HIGH) {
    digitalWrite(5,HIGH);
    delay(50);
    digitalWrite(5,LOW);
    }
    else {
    digitalWrite(5,LOW);
    }

    }

    estadoant = estado; //guardamos el valor actual

    if(salida ==1) { //Estado esta en alto
    digitalWrite(3,HIGH); //prende el led
    }

    else {
    digitalWrite(3,LOW); //De lo contrario lo apagamo
    }

    }

    • Hola José, lo primero fíjate si tienes el pulsador montado en pull-up o en pull-down. y después es mejor que utilices una condición como está para leer el estado del interruptor que quieres montar (en este caso con la resistencia pull-up)

      if ( valor == false ) // esto es que han pulsado el botón
      {
      estado = ! estado ; // cambiamos el estado
      digitalWrite(LED, estado) ; // escribimos el nuevo valor
      delay(250) ;
      }

      De ahí no tienes más que leer si estado está a HIGH y entonces leer el sensor. Un saludo.

    • Luis Melo

    Hola, necesito ayuda para crear un codigo, tengo 2 pulsadores, uno NA y uno NC, los cuales activan una salida del arduino, ejemplo:
    Si presiono el NA, se activa la salida
    Si presiono el NC, se apaga la salida
    Intente con un par de codigos, pero funcionaba cuando queria, tambien queria saber como irian conectados los pulsadores, yo los tengo conectados de la siguiente forma, un extremo del pulsador a los 5V del arduino y el otro extremo a una entrada del arduino y el otro pulsador esta conectado de la misma manera, esta bien?, ojala puedan ayudarme, saludos.

  • Muy interesante el tema, gracias

  • HOLA , me darian una mano con un codigo que no lo puedo lograr . Es para la luz de un auto y lo que quiero hacer es que cuando el pulsador este en estado (HIGH) encienda gradualmente (un led) al brillo maximo y quede encendido si el pulsador sigue en estado (HIGH) , y que cuando el pulsador este en estado (LOW) pocea un delay el led se apague gradualmente .
    MUCHAS GRACIAS !!

    • Hola Juampa, lo que tendrías que hacer es conectar el led a una salida PWM en vez de a una digital. De esa forma puedes encender y apagar el led poco a poco, o dejarlo a mitad de brillo. La forma de hacerlo sería esta

      for ( int i= 0 ; i<255 ; i++)
      {
      analogWrite (9, i) ;
      delay( 10);
      }

      De todas formas, seguro que esta sesión te sirve de ayuda, y si no nos comentas y te ayudamos:
      https://www.prometec.net/pines-cuasi-analogicos/

    • Rodrigo

    Hola!
    tengo una entrada analoga de audio y quiero hacer un killSwitch con arduino, hice programa del boton (no el de on/off) y resulta bien con el led, solo prende cuando esta pulsado. el asunto es que necesito tambien que interrumpa la señal de audio cuando el led está prendido.

    no se me ocurre la manera logica de llegar a eso.

    void setup()
    {
    pinMode( 2, OUTPUT) ;
    pinMode( 3, INPUT) ;
    pinMode( A2 , OUTPUT) ;
    pinMode( A1 , INPUT) ;
    digitalWrite(2 , LOW) ; // Apagamos el LED al empezar
    //digitalWrite(3 , LOW) ; // Apagamos el LED al empezar

    }
    void loop()
    {
    bool valor = digitalRead(3) ; //leemos el botón: false = LOW
    if ( valor == LOW ) // esto es que han pulsado el botón
    {
    digitalWrite(2, LOW);
    analogRead(A1)=analogWrite(A2);
    // escribimos el nuevo valor
    }else{

    digitalWrite(2, HIGH);
    analogRead(A1)!=analogWrite(A2);
    }

    Necesito ayuda con esto por favor

    desdeya, gracias

    • Hola Rodrigo, el kill switch lo quieres para una guitarra? o para una señal de audio en general? Si puedes explícanos un poco más detalladamente tu proyecto a ver si podemos ayudarte. Un saludo.

        • Rodrigo

        Es para una guitarra, además quiero incorporarle un efecto (lo-fi) por lo cual necesito tener otro botón que sea on-off y unas itinerancias en tiras led adjuntas a la entrada de voltaje (aunque se que el nivel de línea está bajo 1V).
        Sería de mucha ayuda si me puedes guiar en esto. Sigo tu blog hace un año aprox y siempre me saca de apuros.

        Desde ya, gracias

        • Hola Rodrigo, la verdad es que no tengo mucha idea de guitarras, o al menos de cómo son por dentro, yo soy más de batería y bajo jejeje. Lo del kill switch supongo que no deberia ser más que poner un pulsador en la o las línea por la que vaya el sonido y que al pulsarlo se abra. Lo del efecto lo-fi y las itinerancias de led no estoy muy seguro de entender qué es. Voy a ver si lo miro un poco, o si no si pudes explícamelo un poco. Un saludo.

        • Rodrigo

        Si, lo es. Pero ademas queiro poner un efecto, para lo cual necesito un boton on-off qur actie el efecto y ademas unos led en los que estoy trabajando, todo esto es con botones arcade. supongo que no habria problema ya que el nivel elecrtico que produce el mic de la guitarra es muy bajo (bajo 1V) y la arduino es de 3.3V y/o 5V (ocupo una mini) por lo cual no debería tener problemas.

        saludos y gracias

        • Hola Rodrigo, controlar una tira de leds desde el arduino es bastante sencillo, se manejan igual que un diodo rgb normal.

          Para activar o desactivar estos efectos deberías usar el pulsador como un interruptor, como hacemos en esta sesión y activar o desactivar todo en función del estado de la variable.

    • JC

    Hola a todos. Agradecería muchísimo si alguien me puede ayudar.
    Tengo un problemilla con sensores magnéticos, y no sabía donde hacer esta pregunta.
    Resulta que estoy haciendo un sistema automático para puertas, que a la hora de cerrar (parar los motores), depende de dos sensores magnéticos (como esos que se ponen en las puertas y ventanas para saber si están abiertas o cerradas).
    Me funciona todo bien excepto ese paso, detectar de forma correcta que las puertas han llegado al final del movimiento esperado, donde los sensores magnéticos pasan a conducir corriente, y en mi programa, al detectarlos, debería parar cada motor.
    Pues lo estoy probando con Leds porque no consigo que me funcione.
    Lo he probado con resistencia desde el sensor a Vcc y sin ella. Con INPUT_PULLUP y con solo INPUT. Y hace lo que le da la gana.
    Este es el ejemplo:
    // SENSORES MAGNETICOS PARA SABER CUANDO LAS PUERTAS ESTAN CERRADAS.
    const int I1 = 40; // I1 = Imán 1
    const int I2 = 41; // I2 = Imán 2
    int Led1 = 50;
    int Led2 = 51;

    void setup(){
    Serial.begin (9600);
    pinMode(I1,INPUT_PULLUP);
    digitalWrite(I1,LOW);
    pinMode(I2,INPUT_PULLUP);
    digitalWrite(I2,LOW);
    pinMode(Led1,OUTPUT);
    pinMode(Led2,OUTPUT);
    }

    void loop(){
    int estadoI1=digitalRead(I1);
    if (estadoI1 == HIGH){
    Serial.println(“Iman 1 detectado”);
    digitalWrite(Led1,HIGH);
    }
    else if (estadoI1 == LOW){
    Serial.println(“Iman 1 NO detectado”);
    digitalWrite(Led1,LOW);
    }
    int estadoI2=digitalRead(I2);
    if (estadoI2 == HIGH){
    Serial.println(“Iiman 2 detectado”);
    digitalWrite(Led2,HIGH);
    }
    else if (estadoI2 == LOW){
    Serial.println(“Iman 2 NO detectado”);
    digitalWrite(Led2,LOW);
    }
    delay(5000);
    }

    Pues, sin acercar los imanes, se encienden y apagan aleatoriamente. Y no se cual es la solución.
    Muchas gracias de antemano.

      • JC

      Encontré la solución. Google sabe de todo (si le sabes preguntar).
      Resulta que yo estaba poniendo los cables de los sensores magnéticos de la siguiente manera: uno a Vcc y el otro cable al pin de entrada (I1 e I2). Pues mal. Lo que he visto por ahí, es que los tengo que poner a tierra (GND). Los he cambiado de Vcc a GND, y he cambiado un poco el código, quedando así:
      // SENSORES MAGNETICOS PARA SABER CUANDO LAS PUERTAS ESTAN CERRADAS.
      const int I1 = 40; // I1 = Imán 1
      const int I2 = 41; // I2 = Imán 2
      int Led1 = 50;
      int Led2 = 51;

      void setup(){
      Serial.begin (9600);
      pinMode(I1,INPUT);
      digitalWrite(I1,HIGH);
      pinMode(I2,INPUT);
      digitalWrite(I2,HIGH);
      pinMode(Led1,OUTPUT);
      pinMode(Led2,OUTPUT);
      }

      void loop(){
      int estadoI1=digitalRead(I1);
      if (estadoI1 == LOW){
      Serial.println(“Iman 1 detectado”);
      digitalWrite(Led1,HIGH);
      }
      else if (estadoI1 == HIGH){
      Serial.println(“Iman 1 NO detectado”);
      digitalWrite(Led1,LOW);
      }
      int estadoI2=digitalRead(I2);
      if (estadoI2 == LOW){
      Serial.println(“Iman 2 detectado”);
      digitalWrite(Led2,HIGH);
      }
      else if (estadoI2 == HIGH){
      Serial.println(“Iman 2 NO detectado”);
      digitalWrite(Led2,LOW);
      }
      delay(5000);
      }

      Y ya me funciona.
      Mañana daré el paso siguiente, probar todo el sistema.
      Un saludo!!!!

  • Hola Buenas Noches
    Primero quiero agradecer por este curso, que la verdad me ha servido bastante para adentrarme de una forma sencilla y entretenida a todo lo que se puede hacer con estos equipos

    mi duda es la siguiente en el comentario de la instrucción siguiente:

    pinMode(boton, INPUT_PULLUP); //Hemos eliminado R3

    Esto quiere decir que ya no es necesario tener la conexión de del pin de 5V y de la resistencia R3 a nuestro circuito??
    Lo pregunto por que lo desconecte estos elementos pensando esto mismo y el circuito funciono correctamente pero temo que pueda dañar algún elemento por no tener esta resistencia conectada

    Si es correcto mi conjetura significa que con INPUT_PULLUP se simplifica el Esquema Electrónico del circuito la cual se describe en la practica anterior y ya no es necesaria esta entrada de 5V?

    Saludos

    • Hola Javo, al poner INPUT_PULLUP en vez de INPUT activas una resistencia interna que nos permite prescindir de la resistencia R3.

      • Muchas Gracias Ivan por el dato
        eso simplifica mucho el circuito

    • David

    Hola, buenas noches, lo primero felicitaros por el curso ya que es de lo mejor que he encontrado, llevo unas semanas estudiando en clase con arduino y mas o menos voy pillando cosas, he conseguido hacer algun programa, pero muy sencillo y sin complicarme con las variables, pero en esta parte del tutorial hay algo que no entiendo muy bien o quizas lo entiendo pero no estoy muy seguro de que sea asi, mi duda es la siguiente:

    int LED = 10 ; int boton = 6 ;
    bool estado = true ;
    bool estado_anterior = true ;

    void setup()
    {
    pinMode(boton, INPUT_PULLUP); /*Hemos eliminado R3 1º(En esta parte ya he leido que se activan las resistencias internas de la placa, y que queda conectada la entrada como pullup, siempre con 5V*/

    pinMode(LED, OUTPUT);
    }

    void loop()
    {
    estado = digitalRead(boton); //2º( Aqui entiendo que la lectura es true ya que la variable estado esta definida como true, ademas el la entra de boton esta en pullup
    if (estado != estado_anterior) /*hay cambio : Han pulsado o soltado 3º(en esta parte estado y estado anterior no son diferentes las dos variables
    estan declaradas como true en la cabecera del programa)*/

    {
    if (estado == LOW) //4º aqui tengo el lio, el estado es HIGH, por lo tanto esta condicion no se cumple, por lo tanto cuando se ejecuta
    digitalWrite(LED, !digitalRead(LED));// 5º En esta parte entiendo que escribe el estado contrario al que lee en la salida del LED
    estado_anterior = estado ; // esta linea esta clara actualiza la variable estado_anterior al estado que tenga el boton
    }
    }

    No se si quedara muy claro donde tengo las dudas, un saludo y muchas felicidades por el curso, esta realmente bien

    • Hola David, al acertarte por primera vez a la programacion resulta dificil aceptar la naturaleza repetitiva de la misma y nos resulta extraño pero recuerda siempre que en arduino tenemos un programma llamado loop que se ejecuta una y otra vez.
      Por eso aun cuando la variable estado incialmente es TRUE, a medida que el programa va avanzando, si hay una pulsacion cambia a false y por eso cambia la variable ) estado = digitalRead(boton) ) cunado lo sueltas vuelve a tru, pero para entonces el loop se ha repetido mil veces

  • Hola, en la instrucción:
    “digitalWrite(LED, !digitalRead(LED));”

    ¿Puede leerse un pin definido como OUTPUT?

    un saludo

    • Hola Francesc, se puede leer el estado de cualquier pin digital, da igual que esté declarado como entrada o salida. Un saludo.

  • Hola, algunas dudas:
    * ¿que quiere decir cuando pone en el comentario: “//Hemos eliminado R3 “?
    * pinMode(boton, INPUT_PULLUP) ==>¿INPUT_PULLUP es distinto a INPUT?
    ¿Hay más valores además de INPUT y OUTPUT posibles para esta función?
    Gracias de antemano por vuestra paciencia ante mi torpeza. Saludos.

    • Hola Pedro, si ambas instrucciones son diferentes porque una activa resistencias de pullup internas y la segunda no

      No existe equivalento con output en arduino ni tampoco existe imput_pulldown hasta donde conozco

  • No acabo de entender la expresion if ( valor == false ) // esto es que han pulsado el botón………..
    No deberia ser true ?

    • Hola Julio, depende de si la resistencia está conectada en pullup o en pulldown. En este caso está en pullup por lo que forzamos una lectura del pulsador a 1 o true cuando está sin pulsar, y a 0 o false cuando está presionado. UN saludo.

    • Sebastian

    muchas gracias necesitaba esto para estar seguro de mi programación y ahora me resolviste las dudas ahora si podre seguir con mi proyecto, de verdad muchas gracias

    • Francisco Martin Tornero

    Hola lo primero gracias por su vuestra ayuda, yo quiero aplicarlo a un teclado analogico controlado con un pin analogico(A0).
    no se como darle la varia tipo si lees la valor de la tecla # activa led y si lees el valor de tecla * para todo.

    Me podies ayudar estoy desesperado.

    un saludo
    muchas gracias de antemano

    • Hola Francisco, no entiendo muy bien tu pregunta

      • A ver lo que me pasa es que con el codigo este :
        switch( opcMenu )
        {
        // Abrir Agua
        case 0:
        if(!strcmp(resultButton,”#”)) // Pulsando Verde enciende.
        {

        if(RELE1 == false) Agua = HIGH; // Si la Intensidad de iluminación es 0 se encenderá como mínimo a 20.
        digitalWrite(RELE1,Agua);
        ledY_E = true;

        }
        case 1:

        if( !strcmp(resultButton,”*”) ) // A la izquierda se apaga.
        {
        digitalWrite(RELE1, false);
        ledY_E = false;
        }

        Pulso el boton # se enciende pero al soltar se apaga yo lo que quiero es pulsar que se que quede activado y al pulsar * que se apague.

        Muchas Gracias

        un saludo

    • Monica Vadillo

    Necesitoooo ayuda!! El 5 binario no se apaga y debe de apagarse

    • Tranqui Monica, que es seguro un problema de cables o de codigo mal. Publica el codigo

    • JAngel

    Hola, genial el tutorial pero.. estoy comenzando y me pregunto, como puedo aplicar esto a una serie de 6 LEDs, por ejemplo que presione y se encienda el primero, al volver a presionar este se apague y se encienda el segundo, al presionar de nuevo se apague el segundo y encienda el tercero, y así sucesivamente.. ?

    • Hola Ángel, tendrías que mezclar esta sesión con la del circuitop con múltiples LED: https://www.prometec.net/circuito-multiples-leds/

      Tendrías que meter el bucle for en el que recorremos los LEDs debntro del if en el que lees el pulsador. Si lo pruebas y no lo consigues o tienes alguna duda me dices y te echo una mano.

      Un saludote!

  • Gracias por la respuesta. No he medido el voltaje del led pero suponiendo que es inferior a 2 voltios crees que sera suficiente para que el pin detecte que esta en alto?

    • Los LEDs necesitan aproximadamente 1.8V para encender (los rojos), y probablemente el cargador entregue 3V o más. Aún así, usando las entradas analógicas puedes leer voltajes pequeños y actuar en consecuencia.

  • Disculpen tengo una duda. Tengo un drone que usa baterias lipo, el problema es que es cargador no tiene proteccion de sobrecarga pero tiene un led que se apaga cuando la bateria esta totalmente cargada. Entonces se me ocurrio que puedo hacer con arduino que al apagarse ese led (el indicador de carga llena) arduino lo detecte como entrada y con un relay apage el cargador suspendiedo la carga. Entonces mi pregunta es que si el voltaje del led que supongo que es 1.xx volts es suficiente para para activar un pin de arduino como entrada y darle la orden de que apague el pin del relay cuando el led se apage. Esperp me haya explicado bien con mi pregunta. Cualquier respuesta ayudara. Gracias

    • Hola Ivan.

      En principio, sí se puede. Mide el voltaje que llega hasta ese LED cuando está encendido, y si son 5V pues perfecto, pues sacas una derivación hacia una entrada de Arduino, y cuando detecte LOW pues todo perfecto. Si son más de 5V, tendrás que utilizar un divisor de tensión para no quemar la entrada.

      Saludos.

Give a Reply

WordPress Anti-Spam by WP-SpamShield