Los joysticks de 2 ejes con procesamiento Arduino son dispositivos versátiles y potentes que permiten controlar diferentes sistemas de manera precisa y eficiente. En este artículo, exploraremos en detalle su funcionamiento, los componentes de su interfaz y cómo puedes programarlo con Arduino para sacarle el máximo provecho a esta útil herramienta. ¡Sigue leyendo para descubrir todo lo que necesitas saber sobre este emocionante dispositivo!
Cuando escuchas la palabra joystick de pulgar, lo primero que te viene a la mente es un controlador de juego. Aunque se usan más comúnmente para juegos, si te gusta la electrónica de bricolaje puedes hacer muchas cosas interesantes con ellos, como controlar un robot o un rover o controlar los movimientos de la cámara.
Profundicemos en el módulo del joystick y veamos cómo funciona.
Descripción general del hardware
Cualquiera que esté familiarizado con el controlador de PS2 (PlayStation 2) notará que este joystick es sorprendentemente similar al que se usa en este dispositivo. Es un joystick autocentrado con resorte que se centra automáticamente cuando se suelta. También cuenta con un cómodo botón/tapa en forma de copa que se siente como un pulgar.
Potenciómetros
La idea básica de un joystick es convertir la posición de la palanca en dos ejes, el eje X (de izquierda a derecha) y el eje Y (arriba y abajo), en una señal eléctrica que un microcontrolador puede procesar. Esto se consigue instalando dos potenciómetros de 5K (uno para cada eje) conectados a un pelota de ejercicio Mecanismo que separa los movimientos “horizontales” y “verticales”.
Los dos cuadros grises a cada lado del joystick son los potenciómetros. Si mueves el joystick mientras observas el potenciómetro, notarás que cada potenciómetro solo detecta movimiento en una dirección. Más adelante entraremos en más detalles sobre cómo funcionan.
Interruptor de botón momentáneo
Este joystick también tiene un interruptor de botón (una pequeña caja negra en un lado del joystick) que se activa cuando presiona el botón del joystick. Cuando se presiona el botón, notará una palanca presionando la cabeza del interruptor. Está diseñado para que la palanca funcione independientemente de la posición del joystick.
¿Cómo funciona el módulo del joystick para el pulgar?
Es realmente sorprendente cómo un joystick puede implementar cada pequeño movimiento de tus dedos. Esto es posible gracias al diseño del joystick, que consta de dos potenciómetros y un mecanismo de cardán.
Mecanismo de cardán
Cuando mueves el joystick, una varilla delgada se asienta entre dos ejes ranurados giratorios (cardán). Uno de los ejes permite el movimiento a lo largo del eje X (izquierda y derecha), mientras que el otro permite el movimiento a lo largo del eje Y (arriba y abajo).
A medida que mueve el joystick hacia adelante y hacia atrás, el eje Y gira. A medida que lo mueve de izquierda a derecha, el eje X gira. Y si lo mueves en diagonal, ambos ejes giran.
Cada eje está conectado a un potenciómetro, por lo que al mover el eje hace girar el limpiador del potenciómetro correspondiente. En otras palabras, cuando empuja la perilla completamente hacia adelante, el control deslizante del potenciómetro se mueve hacia un extremo de la pista de resistencia, y cuando lo tira hacia atrás, se mueve hacia el extremo opuesto.
Al leer estos potenciómetros se puede determinar la posición del botón.
Leer valores analógicos desde el joystick.
El joystick emite una señal analógica cuyo voltaje varía entre 0 y 5 V. Cuando mueves el joystick de un extremo a otro a lo largo del eje X, la salida X cambia de 0 a 5V, y sucede lo mismo cuando lo mueves a lo largo del eje Y. Y cuando el joystick está centrado (posición de reposo), el voltaje de salida es aproximadamente la mitad de VCC o 2,5 V.
Este voltaje de salida se puede alimentar a un ADC en un microcontrolador para determinar la posición física del joystick.
Dado que la placa Arduino tiene una resolución ADC de 10 bits, los valores en cada canal analógico (eje) pueden oscilar entre 0 y 1023. Por tanto, cuando se mueve el joystick de un extremo a otro, muestra un valor entre 0 y 1023 para el canal correspondiente. Cuando el joystick está centrado, tanto el canal vertical como el horizontal muestran 512.
La siguiente figura muestra los ejes X e Y y la respuesta de las salidas cuando el joystick se mueve en diferentes direcciones.
Distribución de pines del módulo de joystick para pulgar
Echemos un vistazo a la distribución de pines del módulo del joystick para el pulgar.
Tierra es el pin de tierra.
VCC suministra energía al módulo. Conéctelo a su suministro positivo (generalmente 5V o 3.3V dependiendo de sus niveles lógicos).
VRx es el voltaje de salida horizontal. Mover el joystick de izquierda a derecha cambia el voltaje de salida de 0 a VCC. El joystick muestra aproximadamente la mitad del VCC cuando está centrado (posición de reposo).
Vry es el voltaje de salida vertical. A medida que mueve el joystick hacia arriba y hacia abajo, el voltaje de salida cambia de 0 a VCC. El joystick muestra aproximadamente la mitad del VCC cuando está centrado (posición de reposo).
SUDOESTE es la salida del interruptor de presión. Por defecto, la salida de conmutación está libre de potencial. Se requiere una resistencia pull-up para leer el interruptor de modo que cuando se presiona el botón del joystick la salida del interruptor pase a BAJA; de lo contrario, permanezca ALTA. Tenga en cuenta que el pin de entrada al que está conectado el interruptor debe tener el pull-up interno habilitado o se debe conectar una resistencia pull-up externa.
Cableado de un módulo de joystick de pulgar a un Arduino
Ahora que sabemos todo sobre el módulo joystick, conectémoslo al Arduino.
Primero, conecte VRx al pin analógico A0 del Arduino y VRy al pin analógico A1. Para detectar si el joystick está presionado conectamos el pin SW del joystick al pin digital D8 de Arduino.
Finalmente, conecte el pin VCC al puerto de 5V y el pin GND al puerto de tierra del Arduino.
La siguiente tabla enumera las conexiones de pines:
| Módulo de palanca de mando | arduino | |
| Tierra | Tierra | |
| VCC | 5V | |
| VRx | A0 | |
| Vry | A1 | |
| SUDOESTE | octavo |
La siguiente imagen muestra cómo conectar el módulo de joystick de pulgar al Arduino.
Eso es todo. Es hora de poner a prueba tus habilidades con el joystick.
Ejemplo 1 de Arduino: lectura del joystick
Aquí hay un boceto simple de Arduino que configura el microcontrolador para leer las entradas y luego enviar continuamente los valores al monitor en serie.
// Arduino pin numbers
const int SW_pin = 8; // digital pin connected to switch output
const int X_pin = 0; // analog pin connected to X output
const int Y_pin = 1; // analog pin connected to Y output
void setup() {
pinMode(SW_pin, INPUT);
digitalWrite(SW_pin, HIGH);
Serial.begin(9600);
}
void loop() {
Serial.print("Switch: ");
Serial.print(digitalRead(SW_pin));
Serial.print(" | ");
Serial.print("X-axis: ");
Serial.print(analogRead(X_pin));
Serial.print(" | ");
Serial.print("Y-axis: ");
Serial.print(analogRead(Y_pin));
Serial.println(" | ");
delay(200);
}Después de cargar el boceto, debería ver el siguiente resultado en el monitor serie.
Explicación del código:
El primer paso del boceto es declarar las conexiones del módulo de joystick.
// Arduino pin numbers
const int SW_pin = 8; // digital pin connected to switch output
const int X_pin = 0; // analog pin connected to X output
const int Y_pin = 1; // analog pin connected to Y outputEn la sección de configuración, configuramos el pin SW para que se comporte como una ENTRADA y lo colocamos en ALTO. También comenzamos con la comunicación serie con el PC.
pinMode(SW_pin, INPUT);
digitalWrite(SW_pin, HIGH);
Serial.begin(9600);En la sección de bucle simplemente usamos el digitalRead() Función para leer el estado del botón y el analogRead() Función para leer pines VRx y VRy. Luego, los valores se muestran en el monitor de serie.
Serial.print("Switch: ");
Serial.print(digitalRead(SW_pin));
Serial.print(" | ");
Serial.print("X-axis: ");
Serial.print(analogRead(X_pin));
Serial.print(" | ");
Serial.print("Y-axis: ");
Serial.print(analogRead(Y_pin));
Serial.println(" | ");
delay(200);Ejemplo 2 de Arduino: animación de los movimientos del joystick en el IDE de procesamiento
Creemos un proyecto Arduino para demostrar cómo se puede usar un módulo de joystick para controlar animaciones en Processing IDE.
Así es como se ve el resultado.
Por supuesto, este proyecto se puede ampliar para animar personajes, realizar vigilancia o controlar aviones no tripulados.
código arduino
En este ejemplo, el estado del botón y de dos salidas analógicas se envían en serie a la computadora. El boceto de procesamiento asociado lee los datos en serie para animar la posición del joystick.
El boceto es idéntico al anterior excepto que los valores impresos en el monitor de serie están separados por comas. El motivo de separar los valores con comas es facilitar la transferencia de datos. El concepto aquí es enviar los valores como Separado por comas Cadena que podemos analizar en el IDE de procesamiento para obtener los valores.
Sube el siguiente boceto a tu Arduino.
int xValue = 0 ; // read value of the X axis
int yValue = 0 ; // read value of the Y axis
int bValue = 0 ; // value of the button reading
void setup()
{
Serial.begin(9600) ; // Open the serial port
pinMode(8,INPUT) ; // Configure Pin 2 as input
digitalWrite(8,HIGH);
}
void loop()
{
// Read analog port values A0 and A1
xValue = analogRead(A0);
yValue = analogRead(A1);
// Read the logic value on pin 2
bValue = digitalRead(8);
// We display our data separated by a comma
Serial.print(xValue,DEC);
Serial.print(",");
Serial.print(yValue,DEC);
Serial.print(",");
Serial.print(!bValue);
// We end with a newline character to facilitate subsequent analysis
Serial.print("n");
// Small delay before the next measurement
delay(10);
}código de procesamiento
Después de cargar el programa en Arduino, podemos comenzar a animar la posición del joystick en Processing IDE. Mantenga su Arduino conectado y ejecute el siguiente código de procesamiento.
import processing.serial.*; //import the Serial library
Serial myPort;
int x; // variable holding the value from A0
int y; // variable holding the value from A1
int b; // variable holding the value from digital pin 2
PFont f; // define the font variable
String portName;
String val;
void setup()
{
size ( 512 , 512 ) ; // window size
// we are opening the port
myPort = new Serial(this, Serial.list()[0], 9600);
myPort.bufferUntil('n');
// choose the font and size
f = createFont("Arial", 16, true); // Arial, 16px, anti-aliasing
textFont ( f, 16 ) ; // size 16px
}
// drawing loop
void draw()
{
fill(0) ; // set the fill color to black
clear() ; // clean the screen
fill(255) ; // set the fill color to white
if (b == 1) // check if the button is pressed
{
// draw a larger circle with specified coordinates
ellipse(x/2,y/2, 50, 50);
}
else
{
// we draw a circle with a certain coordinates
ellipse(x/2,y/2, 25, 25);
}
// we display data
text("AnalogX="+(1023-x)+" AnalogY="+(1023-y),10,20);
}
// data support from the serial port
void serialEvent( Serial myPort)
{
// read the data until the newline n appears
val = myPort.readStringUntil('n');
if (val != null)
{
val = trim(val);
// break up the decimal and new line reading
int[] vals = int(splitTokens(val, ","));
// we assign to variables
x = vals[0];
y = vals[1] ;
b = vals[2];
}
}Explicación del código:
Analicemos rápidamente el código. Primero importamos la biblioteca serial para leer valores desde el puerto serial.
import processing.serial.*; //import the Serial library
Serial myPort;Luego se declaran las variables que contienen los valores del eje x, el eje y y el estado del botón.
int x; // variable holding the value from A0
int y; // variable holding the value from A1
int b; // variable holding the value from digital pin 2
PFont f; // define the font variable
String portName;
String val;En la función de configuración, primero configuramos el tamaño de la ventana en 512×512. A continuación usamos Serial.list()[0] para abrir el primer puerto serie disponible. Si esto no funciona, seleccione el puerto donde está conectado Arduino. También seleccionamos una fuente para mostrar nuestros valores en la ventana.
size ( 512 , 512 ) ; // window size
// we are opening the port
myPort = new Serial(this, Serial.list()[0], 9600);
myPort.bufferUntil('n');
// choose the font and size
f = createFont("Arial", 16, true); // Arial, 16px, anti-aliasing
textFont ( f, 16 ) ; // size 16pxCuando inicia la función de dibujo, el color de fondo de la ventana se establece en negro. Luego elegimos un color blanco para dibujar un pequeño círculo que representa la posición del joystick. Para mostrar que se ha presionado el botón, ampliaremos el círculo.
fill(0) ; // set the fill color to black
clear() ; // clean the screen
fill(255) ; // set the fill color to white
if (b == 1) // check if the button is pressed
{
// draw a larger circle with specified coordinates
ellipse(x/2,y/2, 50, 50);
}
else
{
// we draw a circle with a certain coordinates
ellipse(x/2,y/2, 25, 25);
}Los valores de los ejes xey se imprimen en la esquina superior izquierda de la ventana.
// we display data
text("AnalogX="+(1023-x)+" AnalogY="+(1023-y),10,20);La función personalizada serialEvent(Serial myPort) nos ayuda a analizar una lista de valores separados por comas.
void serialEvent( Serial myPort)
{
// read the data until the newline n appears
val = myPort.readStringUntil('n');
if (val != null)
{
val = trim(val);
// break up the decimal and new line reading
int[] vals = int(splitTokens(val, ","));
// we assign to variables
x = vals[0];
y = vals[1] ;
b = vals[2];
}
}Funcionamiento e Interfaz de Joystick de 2 Ejes con Procesamiento Arduino
Cuando escuchas la palabra joystick de pulgar, lo primero que te viene a la mente es un controlador de videojuegos. Aunque se utilizan principalmente para juegos, puedes hacer muchas cosas geniales con ellos si te gusta la electrónica DIY, como controlar un robot o un vehículo todoterreno, o controlar el movimiento de una cámara.
Visión General del Hardware
Para aquellos familiarizados con el controlador PS2 (PlayStation 2), notarán que este joystick es muy similar al utilizado en ese dispositivo. Es un joystick de resorte auto-centrante, lo que significa que cuando lo sueltas, se centrará automáticamente. También tiene un cómodo botón tipo copa que se siente como un stick para el pulgar.
Potenciómetros: La idea básica detrás de un joystick es convertir la posición del stick en dos ejes: el eje X (de izquierda a derecha) y el eje Y (de arriba a abajo) en una señal eléctrica que un microcontrolador pueda procesar. Para esto, se incorporan dos potenciómetros de 5K (uno para cada eje) conectados con un mecanismo de cardán que separa los movimientos «horizontales» y «verticales».
¿Cómo Funciona el Módulo de Joystick de Pulgar?
Es realmente notable cómo un joystick puede traducir cada pequeño movimiento de tus dedos. Esto es posible gracias al diseño del joystick, que consta de dos potenciómetros y un mecanismo de cardán.
Mecanismo de Cardán: Cuando mueves el joystick, una varilla delgada que se encuentra entre dos ejes rotativos con ranuras (cardán) se mueve. Un eje permite el movimiento a lo largo del eje X (izquierda y derecha), mientras que el otro permite el movimiento a lo largo del eje Y (arriba y abajo).
Cada eje está conectado a un potenciómetro de manera que mover el eje hace girar el contacto deslizante del potenciómetro correspondiente. En otras palabras, empujar la perilla todo lo hacia adelante hará que el contacto del potenciómetro se mueva hacia uno de los extremos de la pista resistiva, y tirar hacia atrás hará que se mueva hacia el extremo opuesto.
Al leer estos potenciómetros, se puede determinar la posición física de la perilla.
Lectura de Valores Analógicos del Joystick
El joystick emite una señal analógica cuyo voltaje varía entre 0 y 5V. Cuando mueves el joystick a lo largo del eje X de un extremo al otro, la salida del X cambia de 0 a 5V, y lo mismo sucede cuando lo mueves a lo largo del eje Y. Y, cuando el joystick está centrado (posición de descanso), el voltaje de salida es aproximadamente la mitad de VCC, o 2.5V.
Este voltaje de salida se puede alimentar a un convertidor analógico-digital en un microcontrolador para determinar la posición del joystick.
Debido a que la placa Arduino tiene una resolución de ADC de 10 bits, los valores en cada canal analógico (eje) pueden variar de 0 a 1023. Por lo tanto, cuando el joystick se mueve de un extremo a otro, leerá un valor entre 0 y 1023 para el canal correspondiente. Cuando el joystick está centrado, los canales vertical y horizontal leerán ambos 512.
El siguiente diagrama representa los ejes X e Y, así como cómo responderán las salidas cuando el joystick se mueve en diferentes direcciones.
- GND: Pin de tierra.
- VCC: Proporciona alimentación al módulo. Conecta esto a tu suministro positivo (generalmente 5V o 3.3V dependiendo de tus niveles lógicos).
- VRx: Salida horizontal de voltaje. Mover el joystick de izquierda a derecha hace que el voltaje de salida cambie de 0 a VCC. El joystick leerá aproximadamente la mitad de VCC cuando esté centrado (posición de reposo).
- VRy: Salida vertical de voltaje. Mover el joystick hacia arriba y abajo hace que el voltaje de salida cambie de 0 a VCC. El joystick leerá aproximadamente la mitad de VCC cuando esté centrado (posición de reposo).
- SW: Salida del interruptor de botón. Por defecto, la salida del interruptor está en reposo. Para leer el interruptor, se requiere una resistencia pull-up para que cuando se presione la perilla del joystick, la salida del interruptor pase a LOW, de lo contrario permanece en HIGH. Ten en cuenta que el puerto de entrada al que se conecta el interruptor debe tener habilitada la resistencia pull-up interna, o se debe conectar una resistencia pull-up externa.
Conexión de un Módulo de Joystick de Pulgar a un Arduino
Ahora que conocemos todo sobre el módulo de joystick, vamos a conectarlo al Arduino. Para comenzar, conecta VRx al pin analógico A0 de Arduino y VRy al pin analógico A1. Para detectar si se ha presionado el joystick, conectamos el pin SW del joystick al pin digital D8 de Arduino.
Finalmente, conecta el pin VCC al terminal de 5V y el pin GND al terminal de tierra del Arduino.
La siguiente tabla enumera las conexiones de los pines:
- Joystick Module – Arduino
- GND – GND
- VCC – 5V
- VRx – A0
- VRy – A1
- SW – 8
La siguiente imagen muestra cómo conectar el módulo de joystick de pulgar al Arduino.
¡Y listo! Es hora de poner a prueba tus habilidades con el joystick.
Ejemplo de Arduino 1 – Lectura del Joystick
Aquí tienes un esquema simple de Arduino que configura el microcontrolador para leer las entradas y luego imprimir continuamente los valores en el monitor serie.
// Números de pin de Arduino
const int SW_pin = 8; // pin digital conectado a la salida del interruptor
const int X_pin = 0; // pin analógico conectado a la salida X
const int Y_pin = 1; // pin analógico conectado a la salida Y
void setup() {
pinMode(SW_pin, INPUT);
digitalWrite(SW_pin, HIGH);
Serial.begin(9600);
}
void loop() {
Serial.print("Interruptor: ");
Serial.print(digitalRead(SW_pin));
Serial.print(" | ");
Serial.print("Eje X: ");
Serial.print(analogRead(X_pin));
Serial.print(" | ");
Serial.print("Eje Y: ");
Serial.print(analogRead(Y_pin));
Serial.println(" | ");
delay(200);
}
Después de cargar el esquema, deberías ver la siguiente salida en el monitor serie.
Explicación del Código:
Como primer paso del esquema, se declaran las conexiones del módulo del joystick.
// Números de pin de Arduino const int SW_pin = 8; // pin digital conectado a la salida del interruptor const int X_pin = 0; // pin analógico conectado a la salida X const int Y_pin = 1; // pin analógico conectado a la salida Y
En la sección de configuración, configuramos el pin SW para comportarse como una entrada y lo ponemos en estado HIGH. También iniciamos la comunicación serie con la PC.
pinMode(SW_pin, INPUT); digitalWrite(SW_pin, HIGH); Serial.begin(9600);
En la sección de loop, simplemente usamos la función digitalRead() para leer el estado del botón y la función analogRead() para leer los pines VRx y VRy. Los valores luego se imprimen en el monitor serie.
Serial.print("Interruptor: ");
Serial.print(digitalRead(SW_pin));
Serial.print(" | ");
Serial.print("Eje X: ");
Serial.print(analogRead(X_pin));
Serial.print(" | ");
Serial.print("Eje Y: ");
Serial.print(analogRead(Y_pin));
Serial.println(" | ");
delay(200);
Ejemplo de Arduino 2 – Animación de Movimientos de Joystick en el IDE de Processing
Vamos a crear un proyecto de Arduino para demostrar cómo un módulo de joystick puede ser utilizado para controlar animaciones en el IDE de Processing.
A continuación se muestra un ejemplo de código de Arduino que envía el estado del botón y dos salidas analógicas de forma serial a la computadora. El esquema de Processing asociado lee los datos seriales para animar la posición del joystick.
Después de cargar el programa a Arduino, podemos comenzar a animar la posición del joystick en el IDE de Processing. Mantén tu Arduino conectado y ejecuta el código de Processing a continuación.
// Importamos la librería Serial
import processing.serial.*;
Serial myPort;
int x; // Variable que contiene el valor de A0
int y; // Variable que contiene el valor de A1
int b; // Variable que contiene el valor del pin digital 2
PFont f; // Definimos la variable de fuente
String portName;
String val;
void setup()
{
size (512, 512); // Tamaño de la ventana
// Abrimos el puerto
myPort = new Serial(this, Serial.list()[0], 9600);
myPort.bufferUntil('n');
// Elegimos la fuente y el tamaño
f = createFont("Arial", 16, true); // Arial, 16px, anti-aliasing
textFont (f, 16); // Tamaño 16px
}
// Bucle de dibujo
void draw()
{
fill(0); // Establecemos el color de relleno en negro
clear(); // Limpiamos la pantalla
fill(255); // Establecemos el color de relleno en blanco
if (b == 1) // Comprobamos si se ha presionado el botón
{
// Dibujamos un círculo más grande en las coordenadas especificadas
ellipse(x/2, y/2, 50, 50);
}
else
{
// Dibujamos un círculo en unas coordenadas específicas
ellipse(x/2, y/2, 25, 25);
}
// Mostramos los datos
text("AnalogX=" + (1023 - x) + " AnalogY=" + (1023 - y), 10, 20);
}
// Soporte de datos desde el puerto serie
void serialEvent(Serial myPort)
{
// Leemos los datos hasta que aparezca el newline n
val = myPort.readStringUntil('n');
if (val != null)
{
val = trim(val);
// Dividimos el decimal y la lectura de newline
int[] vals = int(splitTokens(val, ","));
// Asignamos a variables
x = vals[0];
y = vals[1];
b = vals[2];
}
}
Explicación del código:
Importamos la librería serial para leer valores desde el puerto serie.
Declaramos las variables que contendrán los valores de los ejes x, y y el estado del botón.
En la función de setup, configuramos el tamaño de la ventana, abrimos el puerto serial y elegimos una fuente para mostrar los valores en la ventana.
En el bucle de draw, configuramos el color de relleno y dibujamos un círculo para representar la posición del joystick. Si el botón está presionado, dibujamos un círculo más grande.
Los valores de los ejes se imprimen en la esquina superior izquierda de la ventana.
La función serialEvent() nos ayuda a analizar una lista de valores separados por comas.