Conmutadores Arduino y ruedecilla: 9 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

En este artículo examinamos el uso de interruptores de rueda de empuje / ruedecilla con nuestros sistemas Arduino. A continuación, se muestran algunos ejemplos de PMD Way.

Paso 1:

Para los no iniciados, cada interruptor es un segmento vertical y se pueden conectar entre sí para formar varios tamaños. Puede utilizar los botones para seleccionar de cero a nueve dígitos. Hay alternativas disponibles que tienen una rueda que puede mover con el pulgar en lugar de los botones de aumento / disminución.

Antes de los días de las elegantes interfaces de usuario, estos conmutadores eran métodos bastante populares para configurar la entrada de datos numéricos. Sin embargo, todavía están disponibles en la actualidad, así que veamos cómo funcionan y cómo podemos usarlos. El valor del interruptor está disponible a través de decimal codificado en binario o decimal directo. Considere la parte trasera del interruptor en forma BCD.

Paso 2:

Tenemos el común a la izquierda, luego los contactos para 1, 2, 4 y 8. Si aplica un voltaje pequeño (digamos 5V) al común, el valor del interruptor se puede medir sumando los valores de los contactos que están en el Estado ALTO. Por ejemplo, si selecciona 3, los contactos 1 y 2 estarán en el voltaje en común. Los valores entre cero y nueve se pueden representar como tales en la tabla.

Paso 3:

A estas alturas, debería darse cuenta de que sería fácil leer el valor de un interruptor, y tiene razón, lo es. Podemos conectar 5V al común, las salidas a los pines de entrada digital de nuestras placas Arduino, luego usar digitalRead () para determinar el valor de cada salida. En el bosquejo usamos algunas matemáticas básicas para convertir el valor BCD en un número decimal. Así que hagámoslo ahora.

Desde la perspectiva del hardware, debemos tener en cuenta una cosa más: el interruptor de la rueda de empuje se comporta eléctricamente como cuatro botones de presión normalmente abiertos. Esto significa que necesitamos usar resistencias desplegables para tener una diferencia clara entre los estados alto y bajo. Entonces, el esquema de un interruptor es el que se muestra arriba.

Paso 4:

Ahora es muy sencillo conectar las salidas etiquetadas 1, 2, 4 y 8 a (por ejemplo) los pines digitales 8, 9, 10 y 11. Conecte 5V al punto "C" del interruptor y GND a … GND. A continuación, necesitamos tener un boceto que pueda leer las entradas y convertir la salida BCD a decimal. Considere el siguiente boceto:

/ * Utiliza el protector de pantalla numérico SAA1064 https://www.gravitech.us/7segmentshield.html Utiliza un monitor en serie si no tiene el protector SAA1064 * / #include "Wire.h" #define q1 8 #define q2 9 # define q4 10 #define q8 11 void setup () {Serial.begin (9600); Wire.begin (); // unirse al bus i2c (dirección opcional para el maestro) delay (500); pinMode (q1, ENTRADA); // ruedecilla '1' pinMode (q2, ENTRADA); // ruedecilla '2' pinMode (q4, ENTRADA); // ruedecilla '4' pinMode (q8, ENTRADA); // ruedecilla '8'} void dispSAA1064 (int Count) // envía el entero 'Count' a Gravitech SAA1064 shield {const int lookup [10] = {0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F}; int Miles, cientos, decenas, base; Wire.beginTransmission (0x38); Wire.write (0); Wire.write (B01000111); Wire.endTransmission (); Wire.beginTransmission (0x38); Wire.write (1); Miles = Count / 1000; Cientos = (Count- (Miles * 1000)) / 100; Decenas = (Cuenta - ((Miles * 1000) + (Cientos * 100))) / 10; Base = Cuenta - ((Miles * 1000) + (Cientos * 100) + (Decenas * 10)); Wire.write (búsqueda [Base]); Wire.write (búsqueda [Decenas]); Wire.write (búsqueda [cientos]); Wire.write (búsqueda [miles]); Wire.endTransmission (); retraso (10); } int readSwitch () {int total = 0; if (digitalRead (q1) == HIGH) {total + = 1; } if (digitalRead (q2) == HIGH) {total + = 2; } if (digitalRead (q4) == HIGH) {total + = 4; } if (digitalRead (q8) == HIGH) {total + = 8; } retorno total; } bucle vacío () {dispSAA1064 (readSwitch ()); // envía el valor del interruptor para mostrar el escudo Serial.println (readSwitch ()); // envía el valor del interruptor a la caja del monitor en serie}

La función readSwitch () es la clave. Calcula el valor del interruptor sumando la representación numérica de cada salida del interruptor y devuelve el total como resultado. Para este ejemplo, usamos un protector de pantalla numérico que está controlado por el NXP SAA1064.

Paso 5:

La función readSwitch () es la clave. Calcula el valor del interruptor sumando la representación numérica de cada salida del interruptor y devuelve el total como resultado. Para este ejemplo, usamos un protector de pantalla numérico que está controlado por el NXP SAA1064.

Si no tiene uno, está bien; los resultados también se envían al monitor en serie. Ahora, veámoslo en acción en el video.

Paso 6:

Ok, no parece mucho, pero si necesita una entrada numérica, ahorra mucho espacio físico y ofrece un método de entrada preciso.

Así que ahí lo tienes. ¿Los usaría realmente en un proyecto? Por un dígito, sí. ¿Para cuatro? Probablemente no, quizás sería más fácil usar un teclado de 12 dígitos. Hay una idea …

Paso 7: interruptores múltiples

Ahora examinaremos cómo leer cuatro dígitos y no desperdiciar todos esos pines digitales en el proceso. En su lugar, usaremos el IC de expansión de puerto de 16 bits Microchip MCP23017 que se comunica a través del bus I2C. Tiene dieciséis pines de entrada / salida digitales que podemos usar para leer el estado de cada interruptor.

Antes de seguir adelante, tenga en cuenta que se requieren algunos conocimientos asumidos para este artículo: el bus I2C (partes uno y dos) y el MCP23017. Primero describiremos las conexiones de hardware y luego el boceto de Arduino. Recuerde el esquema utilizado para el ejemplo de interruptor único.

Cuando el interruptor se conectó directamente al Arduino, leemos el estado de cada pin para determinar el valor del interruptor. Lo haremos de nuevo, a mayor escala, utilizando el MCP23017. Considere el diagrama de distribución de pines:

Paso 8:

Contamos con 16 pines, lo que permite conectar cuatro interruptores. Los comunes para cada interruptor todavía se conectan a 5 V, y cada contacto del interruptor todavía tiene una resistencia desplegable de 10k a GND. Luego conectamos los pines 1, 2, 4, 8 del dígito uno a GPBA0 ~ 3; dígito dos 1, 2, 4, 8 a GPA4 ~ 7; el dígito tres 1, 2, 4, 8 a GPB0 ~ 3 y el dígito cuatro 1, 2, 4, 8 a GPB4 ~ 7.

Ahora, ¿cómo leemos los interruptores? Todos esos cables pueden hacerte pensar que es difícil, pero el boceto es bastante simple. Cuando leemos el valor de GPBA y B, se devuelve un byte para cada banco, con el bit más significativo primero. Cada cuatro bits coincidirá con la configuración del interruptor conectado a los pines de E / S correspondientes. Por ejemplo, si solicitamos los datos para ambos bancos de E / S y los interruptores están configurados en 1 2 3 4, el banco A devolverá 0010 0001 y el banco B devolverá 0100 0011.

Usamos algunas operaciones de desplazamiento de bits para separar cada cuatro bits en una variable separada, lo que nos deja con el valor de cada dígito. Por ejemplo, para separar el valor del conmutador cuatro, desplazamos los bits del banco B >> 4. Esto empuja el valor del conmutador tres hacia afuera, y los bits en blanco de la izquierda se vuelven cero.

Para separar el valor del interruptor tres, usamos un compuesto bit a bit & - que deja el valor del interruptor tres. La imagen muestra un desglose de los valores del conmutador binario: muestra los valores de bytes GPIOA y B sin procesar, luego el valor binario de cada dígito y el valor decimal.

Paso 9:

Así que veamos el boceto de demostración:

/ * Ejemplo 40a - Leer cuatro interruptores BCD de rueda pulsador a través de MCP23017, mostrar en SAA1064 / Pantalla LED de 4 dígitos y 7 segmentos * / // MCP23017 pines 15 ~ 17 a GND, la dirección del bus I2C es 0x20 // SAA1064 Dirección del bus I2C 0x38 # include "Wire.h" // para definiciones de dígitos LED int dígitos [16] = {63, 6, 91, 79, 102, 109, 125, 7, 127, 111, 119, 124, 57, 94, 121, 113 }; byte GPIOA, GPIOB, dig1, dig2, dig3, dig4; void initSAA1064 () {// configuración 0x38 Wire.beginTransmission (0x38); Wire.write (0); Wire.write (B01000111); // Salida de 12 mA, sin supresión de dígitos Wire.endTransmission (); } configuración vacía () {Serial.begin (9600); Wire.begin (); // arranca el bus I2C initSAA1064 (); } void loop () {// lee las entradas del banco A Wire.beginTransmission (0x20); Wire.write (0x12); Wire.endTransmission (); Wire.requestFrom (0x20, 1); GPIOA = Wire.read (); // este byte contiene los datos del conmutador para los dígitos 1 y 2 // lee las entradas del banco B Wire.beginTransmission (0x20); Wire.write (0x13); Wire.endTransmission (); Wire.requestFrom (0x20, 1); GPIOB = Wire.read (); // este byte contiene los datos del conmutador para los dígitos 3 y 4 // extrae el valor para cada conmutador // dig1 LHS, dig4 RHS dig4 = GPIOB >> 4; dig3 = GPIOB & B00001111; dig2 = GPIOA >> 4; dig1 = GPIOA y B00001111; // enviar todos los datos de GPIO y conmutadores individuales al monitor serial // por motivos de depuración e interés Serial.print ("GPIOA ="); Serial.println (GPIOA, BIN); Serial.print ("GPIOB ="); Serial.println (GPIOB, BIN); Serial.println (); Serial.print ("dígito 1 ="); Serial.println (dig1, BIN); Serial.print ("dígito 2 ="); Serial.println (dig2, BIN); Serial.print ("dígito 3 ="); Serial.println (dig3, BIN); Serial.print ("dígito 4 ="); Serial.println (dig4, BIN); Serial.println (); Serial.print ("dígito 1 ="); Serial.println (dig1, DEC); Serial.print ("dígito 2 ="); Serial.println (dig2, DEC); Serial.print ("dígito 3 ="); Serial.println (dig3, DEC); Serial.print ("dígito 4 ="); Serial.println (dig4, DEC); Serial.println (); // envía el valor del interruptor a la pantalla LED a través de SAA1064 Wire.beginTransmission (0x38); Wire.write (1); Wire.write (dígitos [dig4]); Wire.write (dígitos [dig3]); Wire.write (dígitos [dig2]); Wire.write (dígitos [dig1]); Wire.endTransmission (); retraso (10); retraso (1000); }

Y para los no creyentes… una demostración en video.

Así que ahí lo tienes. Cuatro dígitos en lugar de uno, y sobre el bus I2C conservando los pines de E / S digitales de Arduino. Con ocho MCP23017, podría leer 32 dígitos a la vez. ¡Diviértete haciendo eso!

Puede solicitar interruptores BCD y decimales en varios tamaños de PMD Way, con envío gratuito en todo el mundo.

Esta publicación presentada por pmdway.com: todo para fabricantes y entusiastas de la electrónica, con envío gratuito en todo el mundo.