Interruptores de palanca

 

Interruptores de palanca: lectura confiable

Un boceto de ejemplo que leerá de manera confiable un interruptor de palanca simple, independientemente del diseño del circuito.

 

Componentes y suministros

Ph a000066 iso (1) ztbmubhmho
Arduino UNO
Cualquier microcontrolador Arduino servirá.
× 1
11026 02
Alambres de unión (genérico)
× 4
Mfr 25frf52 10k sml
resistencia de 10k ohmios
× 1
19c6722 40
Interruptor de palanca, basculante
Si puede obtener un interruptor compatible con placa de pruebas, sería ideal, si no el soldador.
× 1

Aplicaciones y servicios en línea

idea web
IDE de Arduino

Acerca de este proyecto

Leer un interruptor de palanca

A diferencia del omnipresente interruptor de botón que tiene un ciclo de conmutación APAGADO-ENCENDIDO-APAGADO, un interruptor basculante simple tiene un ciclo de conmutación APAGADO-ENCENDIDO o ENCENDIDO-APAGADO: permanecerá en la posición del interruptor hasta que se vuelva a encender.

¿Cosas bastante obvias? Sí, pero si queremos proporcionar una solución de software para leer de manera confiable un interruptor de palanca, o cualquier otro interruptor, debemos comprender los elementos de diseño particulares en juego.

Ok, punto tomado, entonces, ¿por qué no simplemente leer el estado del interruptor usando lectura digital()? Esto nos dirá si el interruptor está BAJO o ALTO.

Sí podemos y durante el 99 % de las veces obtendremos un resultado válido. Sin embargo, y para complicar aún más las cosas, tenemos nuestro viejo enemigo y bagaje en el sentido de que el acto de cambiar físicamente significará invariablemente que experimentaremos ‘ruido’ y ‘rebote’ durante la transición del cambio. . Por lo tanto, si queremos una solución de software que pueda leer de manera confiable un interruptor de palanca el 100 % del tiempo, debemos tener eso en cuenta en nuestro diseño.

No hay problema: hay muchas soluciones de este tipo en Internet que harán esto. Entonces, ¿por qué escribí este artículo? Esto se debe a que quería basarme en mis artículos anteriores y similares sobre los fundamentos de los interruptores (consulte el final de este artículo), para ofrecer una comprensión más profunda y un enfoque alternativo y flexible para el diseño de circuitos de interruptores.

El boceto adjunto ofrece un enfoque para leer un interruptor de palanca que:

  • es flexible en el sentido de que está configurado para los dos estilos comunes de diseño de circuitos interruptores, a saber:

circuit_C1 – circuito con una resistencia pull-up de 10k ohm, inicializado como INPUT, y

circuit_C2 – circuito sin ninguna resistencia externa, inicializado como INPUT_PULLUP

  • permite especificar cualquier diseño de circuito con un cambio en un parámetro de configuración (#define circuit_type)
  • incorpora anti-rebote codificado
  • permite modificar fácilmente el período de rebote (#define debounce), según sea necesario
  • código para leer un interruptor de palanca encapsulado en una función booleana independiente, lo que permite llamarlo e incrustarlo en un boceto según sea necesario
  • proporciona el estado del interruptor de palanca como valor de retorno de llamada de la función de lectura del interruptor y como variable global (current_toggle_status)
  • Establece correctamente el estado del interruptor de palanca después de la configuración ().

Eche un vistazo al boceto, cárguelo y juegue con él. El boceto utiliza el LED incorporado para indicar el estado del interruptor: encendido si está encendido, de lo contrario, apagado. No olvide especificar qué circuito interruptor ha conectado a su placa (#define circuit_type circuit_C1, o #define circuit_type circuit_C2).

Para comprender los dos diseños de circuitos a los que se hace referencia en este artículo/boceto, consulte Comprender y usar interruptores de botón, conceptos básicos.

Otras lecturas

También puede encontrar interesantes y útiles estas contribuciones, del mismo autor:

  • Comprender y usar los interruptores de botón, los conceptos básicos – interruptores de botón, un kit simple pero a menudo complicado. El tutorial explica los entresijos de la implementación de un interruptor de botón simple, con la oportunidad de explorar las diferencias de diseño de circuitos, diferentes métodos de lectura y antirrebote.
  • Interruptores de botón accionados por interrupción – un enfoque y un ejemplo de vinculación de un interruptor de botón a una interrupción externa.
  • interrupciones externas, un marco genérico que admite múltiples interrupciones asíncronas simultáneas. Configure múltiples interrupciones externas con diferentes características y agregue código para proporcionar un procesamiento asíncrono posterior a la interrupción.
  • Alerta de recordatorio programático programado, un marco de programación para alertas asíncronas de tiempo transcurrido y en tiempo real. Establezca cualquier cantidad de alertas de recordatorio (subsegundos o subhoras) y procéselas de forma asíncrona.

Otros recursos en línea

pines digitales

Comprender las interrupciones

¡disfrutar!

codificado

Leer un interruptor de palancaC/C++
Lectura confiable de un interruptor de palanca, independientemente de la configuración del circuito.
// Ron D Bentley, Stafford, UK
// Jan 2021
//
//  This example and code is in the public domain and may be used without restriction and
//  without warranty.
/*
  Reading a simple toggle switch, with debounce
  '''''''''''''''''''''''''''''''''''''''''''''
  This sketch presents a method for reading a simple toggle switch 'cleanly' such
  that any electrical noise created during switch transition is removed.  Without
  this, then simply relying on digitalRead() could provide flaky results.
  
  The sketch has been designed to support two commonly wired switch circuits, as below, but note:

    1.  The digital pin chosen as the input is initialised according to the 'circuit_type' macro
        parameter, either INPUT_PULLUP or INPUT using a call to pinMode(button_switch,circuit_type)
        in the setup() function.
        
        As the conditions for detecting switch on/off are different for each 'circuit_type' (they are
        reversed) this is automatically accommodated for in the reading of the toggle switch.
        The only requirement is to define the 'circuit_type', everything else is
        automatically taken care of.

    2.  The wiring designs for each type of switch circuit are:

        circuit_C1 - With switch pull down resister configured and 'circuit_type' of INPUT

               10K ohm     button      (onboard)
              resister    switch         LED
          ____|<><><>|_______ \___        O
         |              |         |       |
         0v         pin = 2      +5v    pin =
                                    LED_BUILTIN
         ___________________________________
         |            ARDUINO              |

        circuit_C2 - With NO switch pull down resister configured and 'circuit_type' of INPUT_PULLUP

             button     (onboard)
             switch        LED
            ___ \___        O
           |        |       |
         pin 2     0v     pin =
                       LED_BUILTIN
         _______________________
         |       ARDUINO       |
 */
 
#define circuit_C1    INPUT         // switch configured with a 10k ohm pull down resistor
#define circuit_C2    INPUT_PULLUP  // switch simply connected to ground, no resistor
#define circuit_type  circuit_C2    // defines which of the two common circuits types is configured

bool    current_toggle_status =           LOW; // start assuming switch switch is off

int     toggle_switch_pin =   7;
#define debounce              10 // debounce period in milli seconds

#define LED     LED_BUILTIN      // normally pin 13, but this ensures it is set correctly by the compiler

//
// test the toggle switch to see if its status has changed since last look.
// note that, although, switch status is a returned value from the function,
// the current status of the switch 'current_toggle_status' is always maintained
// and can be tested outside of the function at any point/time.
//
bool read_toggle_switch() {
  static long int elapse_time = 0;
  static bool transition_started = false;
  int pin_value;
  pin_value = digitalRead(toggle_switch_pin);  // test current state of toggle pin
  if (circuit_type == circuit_C2) {
    // need to invert HIGH/LOW if circuit design sets pin HIGH representing switch in off state
    // ie inititialised as INPUT_PULLUP
    pin_value = !pin_value;
  }
  if (pin_value != current_toggle_status && !transition_started) {
    // switch change detected so start debounce cycle
    transition_started = true;
    elapse_time = millis();  // set start of debounce timer
  } else {
    if (transition_started) {
      // we are in the switch transition cycle so check if debounce period has elapsed
      if (millis() - elapse_time >= debounce) {
        // debounce period elapse so assume switch has settled down after transition
        current_toggle_status = !current_toggle_status;  // flip status
        transition_started = false;  // cease transition cycle
      }
    }
  }
  return current_toggle_status;
} // end of read_toggle_switch

void setup() {
  pinMode(toggle_switch_pin, circuit_type);  // setup switch read pin in accordance with circuit design
  pinMode(LED, OUTPUT);                      // setup LED pin
  digitalWrite(LED, LOW);                    // ensure LED off
} // end of setup

void loop() {
  digitalWrite(LED_BUILTIN, read_toggle_switch());
}

comentarios

Fuente Arduino.cc