Control de pulsadores con Netduino


 

 

 

 

 

Una de las preguntas más comúnmente hechas para comenzar Netduino 2 usuarios es cómo utilizar un botón. Para los dos ejemplos incluidos aquí vamos a usar el botón de encendido y el lede  internos de la placa .

 

Hay dos formas básicas para utilizar los puertos de entrada digital en el Netduino 2. Podemos configurarlo como un puerto de entrada, donde tendremos que comprobar continuamente el valor del puerto a continuación, realizar una acción basada en este valor o podemos utilizarlo como un puerto de interrupción donde vamos a definir un controlador de evento que se basan en una cambio de valor.

 

Para nuestro primer ejemplo este sencillo programa se iluminará el LED a bordo cuando se presiona el botón del tablero de. Esto se hace comprobando constantemente el estado del puerto de entrada en el bucle while. Cuando se pulsa el botón, el valor es alto y cuando se suelta el valor es bajo. Este valor se pasa directamente al puerto LED.

 

Observe filtro falla del InputPort se fija por falso. El filtro de interferencia se usa para prevenir el rebote del interruptor, que no es un problema en este caso. También hemos establecido el modo Resistencia interno ya que el botón a bordo Netduino 2 tiene una resistencia pulldown.

 

El MCU tiene la capacidad de fijar para pull-up o en modo descolgante ya que tiene ambas capacidades incorporadas para el pasador. Desde que usamos una resistencia pulldown para tirar de la línea de baja y el botón se conecta a la línea de 3,3 V, el botón seguirá siendo baja presionado momento en el que pasará a ALTO luego de vuelta a BAJO cuando se suelta.

?

1 /// <summary>
2 /// Button Tutorial for the Netduino 2 and Netduino Plus 2
3 /// </summary>
4 public class Program
5 {
6     /// <summary>
7     /// Main method runs on startup
8     /// </summary>
9     public static void Main()
10     {
11         // Define a new Output Pin to the Onboard LED
12         // NOTE: Setting initial state of the pin to "false"
13         OutputPort onboardLED = new OutputPort(Pins.ONBOARD_LED, false);
14
15         // Define a new Input Pin to the Onboard Switch
16         // NOTE: Set glitch filter to "false".  This is only needed to
17         //       prevent switch bounce and in this case not needed.
18         // NOTE: The pullup on the MCU is disabled and the onboard switch
19         //       has a pulldown resistor so we set this to "Disabled".
20         // NOTE: The switch has a pulldown resistor and is connected to 3.3 (logic HIGH)
21         //       so the switch will show HIGH when pressed or LOW when released.
22         InputPort button = new InputPort(Pins.ONBOARD_SW1, false, Port.ResistorMode.Disabled);
23
24         // Create a boolean member to hold the button state.
25         bool buttonState = false;
26
27         // Loop forever
28         while (true)
29         {
30             // Read the button's state
31             buttonState = button.Read();
32
33             // Illuminate the LED based on a button press
34             onboardLED.Write(buttonState);
35
36         }
37
38     }
39 }

 

 

 

 

 

 

La caída en el ejemplo de código anterior es el hecho de que tenemos que comprobar constantemente el estado del puerto de entrada y llevar a cabo sobre la base de esa condición. Un método más limpio, más eficiente es utilizar un InterruptPort. El InterruptPort nos permite crear un controlador de eventos para cuando el estado del botón cambia. Un ejemplo es el siguiente:

 

 

/// <summary>
2 /// Button Event Handler Tutorial for the Netduino 2 and Netduino Plus 2
3 /// </summary>
4 public class Program
5 {
6
7     // Define a new Output Pin to the Onboard LED
8     // NOTE: Setting initial state of the pin to "false"
9     private static OutputPort onboardLED = new OutputPort(Pins.ONBOARD_LED, false);
10
11     /// <summary>
12     /// Main method runs on startup
13     /// </summary>
14     public static void Main()
15     {
16         // Define a new Interrupt Port to the Onboard Switch
17         // NOTE: Set glitch filter to "false".  This is only needed to
18         //       prevent switch bounce and in this case not needed.
19         // NOTE: The pullup on the MCU is disabled and the onboard switch
20         //       has a pulldown resistor so we set this to "Disabled".
21         // NOTE: The switch has a pulldown resistor and is connected to 3.3 (logic HIGH)
22         //       so the switch will show HIGH when pressed or LOW when released.
23         // NOTE: Set the Interrupt to fire on both edges (HIGH and LOW). (More Info:http://msdn.microsoft.com/en-us/library/cc532332.aspx)
24         InterruptPort button = new InterruptPort(Pins.ONBOARD_SW1, false, Port.ResistorMode.Disabled, Port.InterruptMode.InterruptEdgeBoth);
25
26         // Create an event handler for the button
27         button.OnInterrupt += new NativeEventHandler(button_OnInterrupt);
28
29         // Wait forever
30         Thread.Sleep(Timeout.Infinite);
31     }
32
33     /// <summary>
34     /// Event Handler for the Button Press
35     /// </summary>
36     /// <param name="port"></param>
37     /// <param name="data"></param>
38     /// <param name="time"></param>
39     private static void button_OnInterrupt(uint port, uint data, DateTime time)
40     {
41         // Activate the LED when button is pressed (data == 1)
42         onboardLED.Write(data == 1);
43     }
44
45 }

 

En este ejemplo por encima de los ajustes son muy similares para el filtro de glitch y el Modo de Resistencia . Un ajuste adicional para el InterruptPort es el modo de interrupción de la que nos hemos fijado para InterruptEdgeBoth . En este escenario, el evento se disparará cuando el pin cambia de bajo a alto o alto a bajo. En esencia, esto nos permite manejar la prensa y la liberación del botón. Cuando esto sucede el evento OnInterrupt se dispara . El controlador de eventos que permite transformar el LED encendido o apagado en función del estado del botón.

 

La parte eficaz de este ejemplo es que el programa se va a dormir después de la inicialización de los puertos. Se despertará cuando se controla el evento , y luego irá a dormir de nuevo hasta el próximo evento .

Yo mencioné al principio me cubra el uso de componentes externos y aquí lo haré. Usted puede utilizar un botón externo o LED externo , ya sea con ejemplo . Usted sólo tendrá que conectar los componentes adecuados . Para este ejemplo vamos a necesitar nuestra Netduino 2, una placa, un botón , un LED y dos resistencias, una de 1kΩ  y una de 470Ω .

 

En ambos casos vamos a querer cambiar los pernos que estamos utilizando a los pines externos en lugar de la en los pines de mesa. Para estos ejemplos cualquiera de los pines digitales (D0-D13) se puede utilizar.

 

Vamos a utilizar D0 y D1 en nuestro ejemplo.

 

Dónde estamos utilizando el bordo LED como así:

OutputPort onboardLED = new OutputPort (Pins.ONBOARD_LED, false);

 

Vamos a querer cambiar utilizando el pin 1 para nuestro ejemplo:

OutputPort onboardLED = new OutputPort (Pins.GPIO_PIN_D1, false);

 

Dónde estamos usando el botón del tablero en que así:

Botón InputPort = new InputPort (Pins.ONBOARD_SW1, falso, Port.ResistorMode.Disabled);

 

Vamos a querer cambiar utilizando Pin 0 para nuestro ejemplo:

Botón InputPort = new InputPort (Pins.GPIO_PIN_D0, falso, Port.ResistorMode.Disabled);

 

 

Fuente aqui

Anuncios

Responder

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

Logo de WordPress.com

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

Imagen de Twitter

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

Foto de Facebook

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

Google+ photo

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

Conectando a %s