Haz una pregunta
  Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos » Arduino y Raspberry Pi
Foros Registrarse ¿Olvidaste tu contraseña?

Temas similares

26/11/2013 #1

Avatar de Meta

Cambio de estado del pulsador para un Led
Hola:

Con este código puedo encender un Led si dejo el botón pulsado, lo malo que al soltar el dedo del pulsador se apaga, siempre igual.

Código:
int val = 0;  

void setup() 
{
  pinMode(PIN_D0, OUTPUT);
  pinMode(PIN_B0, INPUT); 
}

void loop()
{
  val = digitalRead(PIN_B0);  
  if (val == HIGH) 
  {         
    digitalWrite(PIN_D0, LOW);  
  }
  else 
  {
    digitalWrite(PIN_D0, HIGH); 
  }
}
He estado horas y horas investigando y mi idea es no controlar el Led directametne, sino guardar los estados del pulsador en variables y usarlo como flag. Sabiendo su estado ya puedo conseguir lo que quiero, lo que me cuesta conseguirlo.

Lo que quiero es, que si pulso un botón y suelto el dedo, se encienda el Led, al pulsar de nuevo, se apague, como si fuera un interruptor.

Un saludo.
26/11/2013 #2

Avatar de ByAxel

Hola, una forma.
Tratas de hacer un On-Off de un Led con un pulsador? entonces:
> Al accionar el pulsador, proboca que se ejecute una comparación.
> El valor de la variable va a indicar el estado del LED no del pulsador, de ese modo si:
- variable es 1 entonces LED = Off y variable es 0
- variable es 0 entonces LED = On y variable es 1

No es necesario que el estado del pulsador se guarde, basta que al ser pulsado indique que se realice la acción pertinente. Luego están los antirrebotes y otros detalles...
Saludos.
26/11/2013 #3

Avatar de Meta

Buenas:

Por ahora he hecho esto, el Led siempre se queda encendido pulse o no el pulsador.

Código:
int Pulsador = PIN_B0; // Pulsador conectado a GND o masa.
int press = 0;
boolean Flag = true;

void setup()
{
  pinMode(PIN_D0, OUTPUT); // Salida para el Led pin 0 del Teensy ++ 2.0.
  pinMode(Pulsador, INPUT); // Entrada del pulsador.
  digitalWrite(PIN_B0, HIGH);
}

void loop()
{
  press = digitalRead(Pulsador);
  if (press == LOW)
  {
    if(Flag)
    {
      digitalWrite(PIN_D0, HIGH);   // Enciende Led.
      Flag =! Flag;
    }
    else
    {
      digitalWrite(PIN_D0, LOW);    // Apaga el Led.
      Flag =! Flag;
    }
  }
  delay(500);  // Retardo para antirrebotes.
}
Un saludo.



Edito:

Lo he probado así, a veces se enciende, a veces se apaga. Si dejo pulsado el botón, el Led parpadea cada 0.5 segundos. Si lo suelto o dejo de presionar el botón, se queda apagado o encendido.

¿Cómo soluciono esto?

Un saludo.
26/11/2013 #4

Avatar de ByAxel

Meta dijo: Ver Mensaje
Lo he probado así, a veces se enciende, a veces se apaga. Si dejo pulsado el botón, el Led parpadea cada 0.5 segundos. Si lo suelto o dejo de presionar el botón, se queda apagado o encendido.

¿Cómo soluciono esto?
Claro, esto es para todo teclado/pulsador, mientras se siga presionando, va a seguir dando un mismo valor. Lo que se suele implementar (caso básico) es una espera luego que detecta la pulsación, por ejemplo.

Código:
if(pulsa){
   if(flag==1){
      OnLED;
      flag = 0; 
   }
   else{
      OffLED;
      flag = 1;
   }
   while(pulsa);
}
En ese caso, se ejecuta la comparación luego de activar (1) el pulsador y luego pasa a esperar a que el estado vuelva a por defecto que seria (0), por eso lo del While().

En while se puede poner antes o despues, eso provoca que se ejecute la comparación al presionar o al soltar el pulsador... depende que se quiera...
26/11/2013 #5

Avatar de Meta

Hola:

No me sale, ejjejeje.

Aquí el código modificado. En este aso no enciende ni de borma el Led.

Código:
int Pulsador = PIN_B0; // Pulsador conectado a GND o masa.
int press = 0;
boolean Flag = true;

void setup()
{
  pinMode(PIN_D0, OUTPUT); // Salida para el Led pin 0 del Teensy ++ 2.0.
  pinMode(Pulsador, INPUT); // Entrada del pulsador.
  digitalWrite(PIN_B0, HIGH);
}

void loop()
{
  press = digitalRead(Pulsador);
  if (press == LOW)
  {
    if(Flag == 1)
    {
      digitalWrite(PIN_D0, HIGH);   // Enciende Led.
      Flag = 0;
    }
    else
    {
      digitalWrite(PIN_D0, LOW);    // Apaga el Led.
      Flag = 1;
    }
  }
  while(Pulsador);
  delay(250);  // Retardo para antirrebotes.
}
Cambié de while hasta con sus { y }, ahora el Led se comporta como indicaba el principio.
Código:
int Pulsador = PIN_B0; // Pulsador conectado a GND o masa.
int press = 0;
boolean Flag = true;

void setup()
{
  pinMode(PIN_D0, OUTPUT); // Salida para el Led pin 0 del Teensy ++ 2.0.
  pinMode(Pulsador, INPUT); // Entrada del pulsador.
  digitalWrite(PIN_B0, HIGH);
}

void loop()
{
    while(Pulsador)
    {
  press = digitalRead(Pulsador);
  if (press == LOW)
  {
    if(Flag == 1)
    {
      digitalWrite(PIN_D0, HIGH);   // Enciende Led.
      Flag = 0;
    }
    else
    {
      digitalWrite(PIN_D0, LOW);    // Apaga el Led.
      Flag = 1;
    }
  }

  delay(250);  // Retardo para antirrebotes.
    }
}
Saludo.
26/11/2013 #6


¿Tienes algún circuíto antirebotes? Si no lo tienes puedes añadir un retardo en la lectura, es que me huele a que tu problema es con los rebotes:



También tienes opciones hardware tales como:

Circuito antirebote (Hardware)

o incluso poner un 555 como monoestable y dispararlo con el pulsador, la imaginación es el límite
26/11/2013 #7

Avatar de Meta

Por lo que leo en Internet.

El efecto de los rebotes se puede solucionar bien mediante software, o bien por hardware. En la Figura 6-16 se muestran dos circuitos hardware antirrebotes. El circuito de la izquierda emplea un condensador y el de la derecha un flip-flop R-S.


Estos dos sirven y según la gente, prefieren el RS. En mi caso software. No se si haz analizado el programa y lo haz probado fisicamente. Espero que alguien lo haga y me confirmen.

Saludo.
26/11/2013 #8


Si claro, el primer código se analiza en 2 segundos, yo seguiría con el primero, por lo que veo es un arduino muy muy simple, el antirebotes por software es sencillo de implementar, simplemente añadimos un retardo, yo suelo utilizar un valor de 100 ms y despues una comprobación con un flag, es decir, seteando una variable a 1 cuando pulsas el pulsador (valga la redundancia) y cuando esta está a 1 no efectuar cambios, y la vuelvo a poner a 0 cuando el pulsador está a 0, así funciona siempre y no hay problemas de que conmute muchas veces al pulsar solo una vez ni nada parecido. Cualquier duda aquí estamos
26/11/2013 #9

Avatar de ByAxel

Meta dijo: Ver Mensaje
No se si haz analizado el programa y lo haz probado fisicamente. Espero que alguien lo haga y me confirmen.
Suelo utilizar ese método entre otros más complejos, ya que depende...
Funciona... comprobado...
26/11/2013 #10


Yo lo que utilizo es lo dicho, el problema de los retardos por software es que despues del retardo vuelve a revisar el estado del pulsador y lo vuelve a conmutar, y como los humanos somos lentos en comparación con un micro pues a lo mejor cuando pulsas una vez conmuta unas cuantas veces antes de levantar el dedo, por lo cual utilizo también lo del flag, siempre me funciona perfectamente, ahora me pillas algo liado terminando mi web, pero si necesitas que te haga el programa te lo hago sin problema alguno, saludos.
27/11/2013 #11

Avatar de Meta

Hay ejemplos que he visto para hacer esta acción usa dos pulsadores, uno para apagarlo y el otro para encenderlo. La idea funciona, en mi caso no me hace gracia, ya que quiero usar 8 Led con cada pulsador.

Aún sigo traquiniando haber como se hace, varios vídeos en youtube usan los dos pulsadores.

Estab amirando el código en asm del PIC16F84A si saco ideas, está muy ensamblado a pesar que lo entiendo.

Código:
;************************************ Pulsador_05.asm ***********************************
;
;    ===================================================================
;      Del libro "MICROCONTROLADOR PIC16F84. DESARROLLO DE PROYECTOS"
;      E. Palacios, F. Remiro y L. López.        www.pic16f84a.com
;       Editorial Ra-Ma.  www.ra-ma.es
;    ===================================================================
;
; Cada vez que presiona el pulsador conectado a la línea RA4 conmutará el estado de
; un LED conectado a la línea RB1.
;
; ZONA DE DATOS **********************************************************************

    LIST        P=16F84A
    INCLUDE        <P16F84A.INC>
    __CONFIG    _CP_OFF &  _WDT_OFF & _PWRTE_ON & _XT_OSC
    
    CBLOCK 0x0C
    ENDC

#DEFINE Pulsador    PORTA,4        ; Pulsador conectado a RA4.
#DEFINE LED            PORTB,1        ; Línea donde se conecta el diodo LED.

; ZONA DE CÓDIGOS ********************************************************************

    ORG    0                        ; El programa comienza en la dirección 0.
Inicio
     bsf        STATUS,RP0            ; Acceso al Banco 1.
    bsf        Pulsador            ; La línea RA4 se configura como entrada.
    bcf        LED                    ; Se configura como salida.
    bcf        STATUS,RP0            ; Acceso al Banco 0.
    bcf        LED                    ; En principio diodo LED apagado.
Principal
    btfsc    Pulsador            ; ¿Pulsador presionado?, ¿(Pulsador)=0?
    goto    Fin                    ; No. Vuelve a leerlo.
    call    Retardo_20ms        ; Espera que se estabilicen los niveles de tensión.
    btfsc    Pulsador            ; Comprueba si es un rebote.
    goto    Fin                    ; Era un rebote y sale fuera.
    btfsc    LED                    ; Testea el último estado del LED.
     goto    EstabaEncendido
EstabaApagado
    bsf        LED                    ; Estaba apagado y lo enciende.
    goto    EsperaDejePulsar
EstabaEncendido
    bcf        LED                    ; Estaba encendido y lo apaga.
EsperaDejePulsar
    btfss    Pulsador            ; ¿Dejó de pulsar?. ¿(Pulsador)=1?
    goto    EsperaDejePulsar    ; No. Espera que deje de pulsar.
Fin
    goto    Principal

    INCLUDE <RETARDOS.INC>
    END
No sabía que costara tanto hacer esta chorrada, ajjajajajaj ajajaj jajajja.

He intentado hacer algo con switch y case.

Vamos haber si nos sale con pseudocódigos aunque sea.

  1. Configurar pines, un Led y un Pulsador.
  2. Si pulso un pulsador pasa a estado 0 y cuando deje de pulsar se guarda en Flag el valor 1 y el Led queda encendido.
  3. Si pulso otra vez el mismo pulsador, comprueba que Flag está 1, el Led se apaga, Flag vuelve a 0.

Parece sencillo pero me cuesta mucho.
27/11/2013 #12


control de rebotes
Saludos, te dejo unos ejemplos de control de rebotes hechos para la launchpad de TI, pero son compatibles con cualquier plataforma arduino, lo unico que hay que cambiar es la definicion de los pines.
Código PHP:
#define PRESIONADO 0     // pulsador con resistencia pull-up
#define NO_PRESIONADO !PRESIONADO
#define DB_TIME 20       // retraso para rebotes

enum flag {ACTIVOINACTIVOestado_PB_1 INACTIVO;

const 
int LED_1 =  GREEN_LED;    // led conectado al pin 6
const int PB_1  =  PUSH2;        // pulsador conectado al pin 3

void setup() 
{                
  
pinMode(LED_1OUTPUT);     // Salida para el Led 
  
pinMode(PB_1INPUT);       // Entrada para el pulsador
  
digitalWrite(LED_1LOW);   // inicia con LED_1 apagado
}

void loop()
{
    if (
digitalRead(PB_1) == PRESIONADO){
        
delay(DB_TIME);
        if ((
digitalRead(PB_1) == PRESIONADO) && (estado_PB_1 == INACTIVO))
            
estado_PB_1 ACTIVO;
        }
  
    if ((
digitalRead(PB_1) == NO_PRESIONADO) && (estado_PB_1 == ACTIVO)){
        
delay(DB_TIME);
        if (
digitalRead(PB_1) == NO_PRESIONADO){
            
digitalWrite(LED_1, !digitalRead(LED_1));
            
estado_PB_1 INACTIVO;
            }
        }

este ejemplo cambia el estado del LED cuando se suelta el pulsador
Código PHP:
#define PRESIONADO 0     // pulsador con resistencia pull-up
#define DB_TIME 2        // retraso para rebotes
#define MX_DB_CNT 10     // maximo numero de muestras

const int LED_1 =  GREEN_LED;    // led conectado al pin 6
const int PB_1  =  PUSH2;        // pulsador conectado al pin 3

void setup()
{
  
pinMode(LED_1OUTPUT);     // Salida para el Led 
  
pinMode(PB_1INPUT);       // Entrada para el pulsador
  
digitalWrite(LED_1LOW);   // inicia con LED_1 apagado
}

void loop()
{
  
int db_cnt;   // variable local para control de rebotes
  
  
for (db_cnt 0db_cnt MX_DB_CNT;) {
    
delay(DB_TIME);
    
db_cnt = (digitalRead(PB_1) == PRESIONADO) ? db_cnt 0b0;
  }

  
digitalWrite(LED_1, !digitalRead(LED_1));

  for (
db_cnt 0db_cnt MX_DB_CNT;) {
    
delay(DB_TIME);
    
db_cnt = (digitalRead(PB_1) == PRESIONADO) ? 0b0 db_cnt 1;
  }

este ejemplo cambia el eestado del LED cuando se presiona el pulsador
27/11/2013 #13

Avatar de ByAxel

Igual en ASM para PICs, que lo comprendes mejor
Código:
    PROCESSOR 16F628A
    INCLUDE <P16F628A.inc>
    errorlevel -302
    __CONFIG _FOSC_XT & _WDTE_OFF & _PWRTE_OFF & _MCLRE_OFF & _BOREN_ON & _LVP_OFF & _CPD_OFF & _CP_OFF

    cblock  0x20
    flag, vr1, vr2
    endc

#define LED PORTB,1
#define BTN PORTB,0

    ORG 0
    banksel TRISB
    movlw   0x01
    movwf   TRISB
    banksel PORTB
    clrf    PORTB
    clrf    flag

Main:
    btfsc   BTN     ; Espera 0
    goto    Main
    btfsc   flag,0  ; flag = 0?
    goto    Clr
    bsf     LED     ; > On LED
    bsf     flag,0  ;   Flag = 1
    goto    Tmp
Clr:
    bcf     LED     ; > Off LED
    bcf     flag,0  ;   Flag = 0
Tmp:
    btfss   BTN     ; Espera 1 (espera a que suelten el pulsador)
    goto    Tmp
    call    Delay   ; Antirrebote (es un ejemplo, puede estar dentro de la espera)
    goto    Main    ; Continua el ciclo

Delay:
    movlw   .100
    movwf   vr1
    decfsz  vr1,F
    goto    $ - 1
    return
    END
Avces es entretenido programar en asm ...
27/11/2013 #14

Avatar de Meta

Buena gente:

Muchas gracias por la ayuda, no lo había visto, ejjeje. Pues sí, en asm a veces es muy divertido.

He seguido los códigos de un vídeotutorial y funciona.
Código:
int Pulsador = PIN_B0; // Pulsador conectado a GND o masa.
int Led = PIN_D0;      // Led.
int Estado = 0;        // Estado de la variable.
int Estado_Led = 0;    // Estado del led.
int Estado_Anterior = 1; // Inicia Teensy con valor 0, el Led encendido, 1, empieza Led apagado.

void setup()
{
  pinMode(Led, OUTPUT); // Salida para el Led pin 0 del Teensy ++ 2.0.
  pinMode(Pulsador, INPUT); // Entrada del pulsador.
}

void loop()
{
  Estado = digitalRead(Pulsador); // Lee el estado del botón.
  
  if ((Estado == HIGH) && (Estado_Anterior == LOW))
  {
    Estado_Led = 1 - Estado_Led;
    delay(20);
  }
  
  Estado_Anterior = Estado;
  
  if (Estado_Led == 1)
  {
   digitalWrite(Led, HIGH); 
  }
  else
  {
  digitalWrite(Led, LOW);
  }
}

No me gusta mucho tanto lío de códigos, seguro que se puede simplificar mejor. Voy a investigar como hacerlo. Cuanto menos código mejor que mejor. También quiero simplificarlo ya que usaré la EEPROM para que se guarde los valores de los estados de los Leds y los recupere al encender Teensy ++ 2.0.

Hablando del asm para el PIC, me he entretenido en aprender algo de la EEPROM para guardar los estados de los Led y nunca lo he conseguido, cuesta mucho, al menos para el PIC16F886.

Pueden dar sus sugerencias.

Gracias a todos.
28/11/2013 #15

Avatar de Meta

Hola de nuevo:

Provando el código con dos pulsadores para un Led y un ventilador, me funciona las pruebas de maravilla.

Solo me queda optimizar el código, al menos el de un pulsador.

Código:
int Pulsador_1 = PIN_B0;     // Pulsador conectado a GND o masa.
int Pulsador_2 = PIN_B1;     // Pulsador conectado a GND o masa.
int Led = PIN_D0;            // Led.
int Ventilador = PIN_D1;     // Ventilador 12 Vdc.
// int Led_Teensy = PIN_D6;     // Led naranja que incorpora Teensy ++ 2.0.
int Estado_1 = 0;            // Estado de la variable.
int Estado_2 = 0;
int Estado_Led = 0;          // Estado del led.
int Estado_Ventilador = 0;
int Estado_Anterior_1 = 1;   // Inicia Teensy con valor 0, el Led encendido, 1, empieza Led apagado.
int Estado_Anterior_2 = 0;   // El ventilador desactivado en este caso. Por temas de polaridad con el L293D.

void setup()
{
  pinMode(Led, OUTPUT);       // Salida para el Led pin 0 del Teensy ++ 2.0.
  pinMode(Ventilador, OUTPUT);
  pinMode(Pulsador_1, INPUT); // Entrada del pulsador 1.
  pinMode(Pulsador_2, INPUT);
}

void loop()
{
  
  // Pulsador Led.
  Estado_1 = digitalRead(Pulsador_1); // Lee el estado del botón.
  
  if ((Estado_1 == HIGH) && (Estado_Anterior_1 == LOW))
  {
    Estado_Led = 1 - Estado_Led;
    delay(20);
  }
  
  Estado_Anterior_1 = Estado_1;
  
  if (Estado_Led == 1)
  {
   digitalWrite(Led, HIGH); 
  }
  else
  {
  digitalWrite(Led, LOW);
  }
  
  // **************************************************************
  
  // Pulsador Ventilador.
    Estado_2 = digitalRead(Pulsador_2); // Lee el estado del botón.
  
  if ((Estado_2 == HIGH) && (Estado_Anterior_2 == LOW))
  {
    Estado_Ventilador = 1 - Estado_Ventilador;
    delay(20);
  }
  
  Estado_Anterior_2 = Estado_2;
  
  if (Estado_Ventilador == 1)
  {
   digitalWrite(Ventilador, HIGH); 
  }
  else
  {
  digitalWrite(Ventilador, LOW);
  }
}
Les dejo el vídeo.

https://www.youtube.com/watch?v=KCO_J5C3_Xc

Saludo.
28/11/2013 #16

Avatar de Meta

Código más simple a la hora de encender y apagar el Led.

Código:
int Pulsador = PIN_B0;            // Pulsador conectado a GND o masa.
int Led = PIN_D0;                 // Led.
boolean Estado;                   // Estado de la variable.
boolean Estado_Led = true;        // Estado del led. Par que inicie el LEd apagado.
boolean Estado_Anterior = false;  // 

void setup()
{
  pinMode(Led, OUTPUT);           // Salida para el Led pin 0 del Teensy ++ 2.0.
  pinMode(Pulsador, INPUT);       // Entrada del pulsador.
}

void loop()
{
  Estado = digitalRead(Pulsador); // Lee el estado del botón.
  delay(20);                      // Antirebotes.
  if (Estado && !Estado_Anterior) // Pulsas por primera vez (paso de low a high).
  {
    Estado_Anterior=true;         // No enta en el if hasta q sueltes el pulsador
    Estado_Led =! Estado_Led;     // De encendido a apagado y viceversa
    digitalWrite(Led, Estado_Led); 
  }
  if (!Estado && Estado_Anterior) // Pulsador soltado (paso de high a low)
  {Estado_Anterior = false;}      // Ya permitimos volver a encender o apagar
}
28/11/2013 #17


Plas Plas! Aplausos, simple, bonito, elegante y sobre todo efectivo
28/11/2013 #18

Avatar de Meta

Buenas:

Seguro que habrá alguien por ahí aunque sea un Ruso capaz de hacerlo mucho mejor.

Ahora un ejemplo abajo para controlar 8 Led y 8 pulsadores, menuda maraña de códigos, ejejjejejej.

No se en C, pero en ensamblador de PIC hay algo que se llama tablas y se simplifica mucho hacer este tipo de cosas. Hablo de tabla de la verdad. investigaré si existe algo parecido pero en C. Lo comento porque a lo mejor, con ese método a parte de no ser tan engorroso, es mucho menos códigos y menos memoria Flash del AVR.

Aquí dejo el código un poco pequeño.
Código:
int Pulsador_1 = PIN_B0;            // Pulsador conectado a GND o masa.
int Pulsador_2 = PIN_B1;
int Pulsador_3 = PIN_B2;
int Pulsador_4 = PIN_B3;
int Pulsador_5 = PIN_B4;
int Pulsador_6 = PIN_B5;
int Pulsador_7 = PIN_B6;
int Pulsador_8 = PIN_B7;
int Led_1 = PIN_D0;                 // Led.
int Led_2 = PIN_D1;
int Led_3 = PIN_D2;
int Led_4 = PIN_D3;
int Led_5 = PIN_D4;
int Led_6 = PIN_D5;
int Led_7 = PIN_D6;
int Led_8 = PIN_D7;
boolean Estado_1;                   // Estado de la variable.
boolean Estado_2; 
boolean Estado_3; 
boolean Estado_4; 
boolean Estado_5; 
boolean Estado_6; 
boolean Estado_7; 
boolean Estado_8; 
boolean Estado_Led_1 = true;        // Estado del led. Par que inicie el LEd apagado.
boolean Estado_Led_2 = false; 
boolean Estado_Led_3 = true; 
boolean Estado_Led_4 = true; 
boolean Estado_Led_5 = true; 
boolean Estado_Led_6 = true; 
boolean Estado_Led_7 = true; 
boolean Estado_Led_8 = true; 
boolean Estado_Anterior_1 = false;
boolean Estado_Anterior_2 = false;
boolean Estado_Anterior_3 = false;
boolean Estado_Anterior_4 = false;
boolean Estado_Anterior_5 = false;
boolean Estado_Anterior_6 = false;
boolean Estado_Anterior_7 = false;
boolean Estado_Anterior_8 = false;

void setup()
{
  pinMode(Led_1, OUTPUT);           // Salida para el Led pin 0 del Teensy ++ 2.0.
  pinMode(Led_2, OUTPUT);
  pinMode(Led_3, OUTPUT);
  pinMode(Led_4, OUTPUT);
  pinMode(Led_5, OUTPUT);
  pinMode(Led_6, OUTPUT);
  pinMode(Led_7, OUTPUT);
  pinMode(Led_8, OUTPUT);
  pinMode(Pulsador_1, INPUT);       // Entrada del pulsador.
  pinMode(Pulsador_2, INPUT);
  pinMode(Pulsador_3, INPUT);
  pinMode(Pulsador_4, INPUT);
  pinMode(Pulsador_5, INPUT);
  pinMode(Pulsador_6, INPUT);
  pinMode(Pulsador_7, INPUT);
  pinMode(Pulsador_8, INPUT);
}

void loop()
{
  // 1) =====================================================
  Estado_1 = digitalRead(Pulsador_1); // Lee el estado del botón.
  delay(20);                      // Antirebotes.
  if (Estado_1 && !Estado_Anterior_1) // Pulsas por primera vez (paso de low a high).
  {
    Estado_Anterior_1 = true;         // No enta en el if hasta q sueltes el pulsador.
    Estado_Led_1 =! Estado_Led_1;     // De encendido a apagado y viceversa.
    digitalWrite(Led_1, Estado_Led_1); 
  }
  if (!Estado_1 && Estado_Anterior_1) // Pulsador soltado (paso de high a low).
  {Estado_Anterior_1 = false;}      // Ya permitimos volver a encender o apagar.
  
    // 2) =====================================================
  Estado_2 = digitalRead(Pulsador_2); // Lee el estado del botón.
  delay(20);                      // Antirebotes.
  if (Estado_2 && !Estado_Anterior_2) // Pulsas por primera vez (paso de low a high).
  {
    Estado_Anterior_2 = true;         // No enta en el if hasta q sueltes el pulsador.
    Estado_Led_2 =! Estado_Led_2;     // De encendido a apagado y viceversa.
    digitalWrite(Led_2, Estado_Led_2); 
  }
  if (!Estado_2 && Estado_Anterior_2) // Pulsador soltado (paso de high a low).
  {Estado_Anterior_2 = false;}      // Ya permitimos volver a encender o apagar.

    // 3) =====================================================
  Estado_3 = digitalRead(Pulsador_3); // Lee el estado del botón.
  delay(20);                      // Antirebotes.
  if (Estado_3 && !Estado_Anterior_3) // Pulsas por primera vez (paso de low a high).
  {
    Estado_Anterior_3 = true;         // No enta en el if hasta q sueltes el pulsador.
    Estado_Led_3 =! Estado_Led_3;     // De encendido a apagado y viceversa.
    digitalWrite(Led_3, Estado_Led_3); 
  }
  if (!Estado_3 && Estado_Anterior_3) // Pulsador soltado (paso de high a low).
  {Estado_Anterior_3 = false;}      // Ya permitimos volver a encender o apagar.

    // 4) =====================================================
  Estado_4 = digitalRead(Pulsador_4); // Lee el estado del botón.
  delay(20);                      // Antirebotes.
  if (Estado_4 && !Estado_Anterior_4) // Pulsas por primera vez (paso de low a high).
  {
    Estado_Anterior_4 = true;         // No enta en el if hasta q sueltes el pulsador.
    Estado_Led_4 =! Estado_Led_4;     // De encendido a apagado y viceversa.
    digitalWrite(Led_4, Estado_Led_4); 
  }
  if (!Estado_4 && Estado_Anterior_4) // Pulsador soltado (paso de high a low).
  {Estado_Anterior_4 = false;}      // Ya permitimos volver a encender o apagar.
  
      // 5) =====================================================
  Estado_5 = digitalRead(Pulsador_5); // Lee el estado del botón.
  delay(20);                      // Antirebotes.
  if (Estado_5 && !Estado_Anterior_5) // Pulsas por primera vez (paso de low a high).
  {
    Estado_Anterior_5 = true;         // No enta en el if hasta q sueltes el pulsador.
    Estado_Led_5 =! Estado_Led_5;     // De encendido a apagado y viceversa.
    digitalWrite(Led_5, Estado_Led_5); 
  }
  if (!Estado_5 && Estado_Anterior_5) // Pulsador soltado (paso de high a low).
  {Estado_Anterior_5 = false;}      // Ya permitimos volver a encender o apagar.
  
    // 6) =====================================================
  Estado_6 = digitalRead(Pulsador_6); // Lee el estado del botón.
  delay(20);                      // Antirebotes.
  if (Estado_6 && !Estado_Anterior_6) // Pulsas por primera vez (paso de low a high).
  {
    Estado_Anterior_6 = true;         // No enta en el if hasta q sueltes el pulsador.
    Estado_Led_6 =! Estado_Led_6;     // De encendido a apagado y viceversa.
    digitalWrite(Led_6, Estado_Led_6); 
  }
  if (!Estado_6 && Estado_Anterior_6) // Pulsador soltado (paso de high a low).
  {Estado_Anterior_6 = false;}      // Ya permitimos volver a encender o apagar.
  
    // 7) =====================================================
  Estado_7 = digitalRead(Pulsador_7); // Lee el estado del botón.
  delay(20);                      // Antirebotes.
  if (Estado_7 && !Estado_Anterior_7) // Pulsas por primera vez (paso de low a high).
  {
    Estado_Anterior_7 = true;         // No enta en el if hasta q sueltes el pulsador.
    Estado_Led_7 =! Estado_Led_7;     // De encendido a apagado y viceversa.
    digitalWrite(Led_7, Estado_Led_7); 
  }
  if (!Estado_7 && Estado_Anterior_7) // Pulsador soltado (paso de high a low).
  {Estado_Anterior_7 = false;}      // Ya permitimos volver a encender o apagar.
  
      // 8) =====================================================
  Estado_8 = digitalRead(Pulsador_8); // Lee el estado del botón.
  delay(20);                      // Antirebotes.
  if (Estado_8 && !Estado_Anterior_8) // Pulsas por primera vez (paso de low a high).
  {
    Estado_Anterior_8 = true;         // No enta en el if hasta q sueltes el pulsador.
    Estado_Led_8 =! Estado_Led_8;     // De encendido a apagado y viceversa.
    digitalWrite(Led_8, Estado_Led_8); 
  }
  if (!Estado_8 && Estado_Anterior_8) // Pulsador soltado (paso de high a low).
  {Estado_Anterior_8 = false;}      // Ya permitimos volver a encender o apagar.
}
28/11/2013 #19

Avatar de ByAxel

Pueden ser con Arrays de datos o tambien con estructura de datos... para el primero se necesita una variable como puntero para acceder a un dato dentro del array y el segundo es algo como:
Código:
struct MyStruct{
 int TipoA;
 int TipoB;
}
y se accede como:
MyStruct.TipoA = 16;
Var1 = MyStruct.TipoB;
Básicamente son así pero hay formas más complejas de formar una estructura...

Para el ejemplo que pones va mejor un array...
Código:
byte Stados[8];
...
Stados[0] = 1; // Cuado se escribe un estado
...
if(Stados[i]==1)... // Dentro de un bucle
28/11/2013 #20

Avatar de Meta

Gracias.

Otra cosa. ¿Cónde se guardan los porgramas compilados, los hex?

Si le doy en buscar, me salen el de los ejemplos de Arduino que vienen incluidos. Mirando donde tengo guardados mis programas, tampoco aparecen. ¿Dónde están?

Un saludo.
¿Tienes una mejor respuesta a este tema? ¿Quieres hacerle una pregunta a nuestra comunidad y sus expertos? Registrate

Buscar más temas sobre:
Lupa Arduino y Raspberry Pi

Cerrar
Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos » Arduino y Raspberry Pi

Powered by vBulletin® Version 3.8.4
Copyright ©2000 - 2017, Jelsoft Enterprises Ltd.
Search Engine Optimization by vBSEO ©2011, Crawlability, Inc.