Saltar al contenido

Usando un Arduino Uno R3 como controlador de juego

julio 4, 2021
FYELE81HI3TXWPS

ACTUALIZACIÓN DE 2016: Ya no brindaré apoyo en la sección de comentarios. Este es un método obsoleto y obsoleto que tiene muy pocas razones para ser utilizado. Manteniéndolo actualizado solo con fines informativos.

Naturalmente, el Uno no admite de forma nativa los golpes de teclado, a diferencia de su hermano Leonardo. La mayoría de Google le dirá que necesita hacer algunas soluciones de firmware y reprogramar ATMEGA solo para que funcione y toda la prueba es un desastre. Si eres como yo, lo has descubierto justo después de comprar uno. A continuación, se explica cómo solucionar todo eso utilizando un poco de codificación Java. La solución ideal sería comprar un tablero de botones de joystick para arcade o simulador de vuelo o un Arduino Leonardo por unos pocos dólares en China (DX.com).

Necesitará:
Arduino Uno
Cualquier tipo de botón o interruptor (o múltiples interruptores, pero comience simple)
Resistencia (es) de 10kΩ (una para cada botón)
Eclipse (el front-end para la programación Java; instrucciones más adelante para la instalación)
Software Arduino (el front-end para la programación Arduino)
Tablero de circuitos
Cables de puente
Paciencia
Cualquier videojuego para el que quieras interruptores físicos (simulador de carreras / vuelo)

Paso 1: instalar y probar el software

Instalación y prueba del software

En primer lugar, necesitará Eclipse (http://www.eclipse.org/downloads/). Para este tutorial, usaré Eclipse Classic 4.2.2 – 64 bits. Si tiene problemas durante la instalación, consulte a Google o al PREGUNTAS MÁS FRECUENTES. Ahora que Eclipse está instalado, también necesitará el programa Arduino (http://arduino.cc/en/main/software). Estaré usando el establo 1.0.5 versión.

Puede omitir este paso si sabe cómo cargar bocetos en Arduino. Ahora que tiene todo el software instalado, vamos a seguir adelante y configurar Arduino primero. En el software Arduino, haga clic en herramientas y asegúrese de que la placa y el número de puerto tengan sentido de acuerdo con Administrador de dispositivos. Para probar la placa, ve Archivo> Ejemplos> Básico> Parpadeo luego presione la flecha en la parte superior izquierda que dice cargar. Si todo va bien, el SMD en el pin 13 debería parpadear. Referirse a ESTO si tiene dificultades.

Paso 2: Cableado de un interruptor y programación básicos

Cableado de un interruptor y programación básicosCableado de un interruptor y programación básicosCableado de un interruptor y programación básicos

En este paso, conectará un interruptor básico al pin 5. ¿Por qué pin 5? No tengo idea, pero aquí está el diagrama de cableado (hecho con Fritzing). Hay dos diagramas, uno para (1) interruptor de 2 pines y otro para (4) interruptores de 4 pines.

Ahora que tiene un interruptor conectado al pin 5, comenzamos a programar en Arduino. El código que utilicé se adjunta a continuación:

// *******************************************
// esta constante no cambiará:
const int buttonPin = 5; // el pin al que se adjunta el pulsador

// Las variables cambiarán:
int buttonState = 0; // estado actual del botón
int lastButtonState = 0; // estado anterior del botón

configuración vacía () {
// Inicializa el pin del botón como entrada:
pinMode (buttonPin, INPUT);
// Inicializar la comunicación serial:
Serial.begin (9600);
}

bucle vacío () {
// Leer el pin de entrada del pulsador:
buttonState = digitalRead (buttonPin);

if (buttonState == HIGH) {
// Si el estado actual es ALTO, entonces el botón
// Enviar a la serie que el motor ha arrancado:
Serial.println (“Iniciar motor”);
retraso (100);
}
// Guarda el estado actual como último estado,
// para la próxima vez a través del bucle
lastButtonState = buttonState;
}
// *******************************************

Cuando se carga en Arduino, puede abrir el monitor de serie (Herramientas> Monitor de serie) y presione el botón. Debería mostrar “Start Engine” siempre que presione el botón. Puede jugar con el retraso más adelante para adaptarse a su gusto, pero tenga en cuenta que esto puede causar problemas en el juego. Ahora está enviando una cadena en serie a través de comentarios táctiles. ¡Esto es genial!

Paso 3: configurar Eclipse e instalar bibliotecas

Configuración de Eclipse e instalación de bibliotecas

Ahora tenemos que hacer algo con esa cadena serial. Un programa necesita recogerlo y traducirlo a pulsaciones de teclas. Aquí es donde entra Eclipse y las cosas se complican. De inmediato, deberá descargar e instalar el RXTXcomm Biblioteca (http://rxtx.qbang.org/wiki/index.php/Download) en Eclipse. Usé el rxtx 2.1-7r2 (estable) versión. Lugar RXTXcomm.jar en Eclipse [Your workspace]/ lib / jars carpeta, así como colocar el rxtxParallel.dll y rxtxSerial.dll archivos en [Your workspace]/ natives-win. Aquí es donde la mayoría de la gente se equivocará si lo hace, no dude en preguntar si tiene alguna pregunta.

Ahora que ha instalado la biblioteca RXTXcomm, podemos comenzar a codificar en Eclipse. Ábrelo y vete Archivo> Nuevo> Proyecto …> Proyecto Java. En aras de la simplicidad y la facilidad, nombre este proyecto SerialTest. Si bien este puede no ser el método adecuado, no hay razón para que no funcione de esta manera. Hacer clic terminar. Debajo de la barra lateral del explorador de paquetes, haga clic con el botón derecho en la carpeta SerialTest y vaya Nuevo> Clase también nombraremos este SerialTest. Asegurarse public static void main (cadena[] argumentos) está marcado. Este es un programa Java en su forma más simple, sin embargo, todavía necesitamos importar esas bibliotecas de antes. Haga clic derecho en la misma carpeta del proyecto y vaya Ruta de compilación> Configurar ruta de compilación. Bajo la Bibliotecas pestaña, haga clic en Agregar archivos JAR externos y navegue hasta donde puso el RXTXcomm.jar ([Your workspace]/ lib / jars) y ábralo. Hacer clic OK. Ahora está listo para comenzar a programar Java utilizando la biblioteca de comunicación en serie.

Si ha superado esta parte, felicitaciones. No pasaste horas tratando de resolverlo como lo hice yo.

Paso 4: Programación en Java para interpretar la serie y las pruebas entrantes

Programación en Java para interpretar pruebas y series entrantes

Ahora, cuéntame porque sé que a nadie le gusta trabajar con el código de otras personas. Simplemente apesta. Puede que tenga que modificar el Canal COM, paridad, bits de parada y velocidad en baudios (datos) configuraciones en el código (todas las cuales se pueden determinar a través del Administrador de dispositivos, pero deben ser las mismas que las del código). El siguiente código funciona con Linux, Mac OS X y Windows. Mi Arduino está en el COM1 predeterminado a 9600b / s. Dejé accidentalmente un código experimental allí mientras creaba una GUI, pero no afectarán nada, así que intente ignorar la comprensión de algunas de las importaciones de la biblioteca. La carpeta SerialTest también se adjunta como referencia.

// *******************************************

import java.awt.AWTException;
importar java.awt.Robot;
import java.awt.event.KeyEvent;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import java.util.Enumeration;
importar javax.swing. *;
importar javax.swing.event. *;
importar java.awt. *;
importar java.awt.event. *;
import javax.swing.JFrame;
import java.awt.Color;

public class SerialTest implementa SerialPortEventListener {
SerialPort serialPort;
/ ** El puerto que usaremos normalmente. * /
Cadena final estática privada PORT_NAMES[] = {“/dev/tty.usbserial-A9007UX1”, // Mac OS X
“/ dev / ttyUSB0”, // Linux
“COM1”, // Windows
};
/ **
* Un BufferedReader que será alimentado por un InputStreamReader convirtiendo el
* bytes en caracteres que hacen que la página de códigos de resultados mostrada sea independiente
* /
entrada privada BufferedReader;
/ ** El flujo de salida al puerto * /
salida OutputStream privada;
/ ** Milisegundos para bloquear mientras se espera que se abra el puerto * /
privado estático final int TIME_OUT = 2000;
/ ** Bits por segundo predeterminados para el puerto COM. * /
privado estático final int DATA_RATE = 9600;

public void initialize () {
CommPortIdentifier portId = null;
Enumeración portEnum = CommPortIdentifier.getPortIdentifiers ();

// Primero, busque una instancia de puerto serie según lo establecido en PORT_NAMES.
while (portEnum.hasMoreElements ()) {
CommPortIdentifier currPortId = (CommPortIdentifier) ​​portEnum
.nextElement ();
para (String portName: PORT_NAMES) {
if (currPortId.getName (). es igual a (portName)) {
portId = currPortId;
rotura;
}
}
}
System.out.println (“ID de puerto:”);
System.out.println (portId);
System.out.println (“”);
if (portId == null) {
System.out.println (“No se pudo encontrar el puerto COM”);
regreso;
}

intentar {
// abre el puerto serie y usa el nombre de clase para appName.
serialPort = (SerialPort) portId.open (this.getClass (). getName (),
SE ACABÓ EL TIEMPO);

// establecer los parámetros del puerto
serialPort.setSerialPortParams (DATA_RATE, SerialPort.DATABITS_8,
SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);

// abre las corrientes
input = new BufferedReader (nuevo InputStreamReader (
serialPort.getInputStream ()));
salida = puerto serial.getOutputStream ();

// agregar oyentes de eventos
serialPort.addEventListener (esto);
serialPort.notifyOnDataAvailable (verdadero);
} captura (Excepción e) {
System.err.println (e.toString ());
}
}

/ **
* Esto debería llamarse cuando deje de usar el puerto. Esto evitará
* Bloqueo de puertos en plataformas como Linux.
* /
público sincronizado void close () {
if (serialPort! = null) {
serialPort.removeEventListener ();
serialPort.close ();
}
}

/ **
* Manejar un evento en el puerto serial. Lea los datos e imprímalos.
* /
public sincronizado void serialEvent (SerialPortEvent oEvent) {
if (oEvent.getEventType () == SerialPortEvent.DATA_AVAILABLE) {
intentar {
String inputLine = input.readLine ();
// DE ARRANQUE DEL MOTOR
if (inputLine.equals (“Iniciar motor”)) {
System.out.println (“Arranque del motor activado”);
intentar {
Robot robot = nuevo Robot ();
robot.keyPress (KeyEvent.VK_S);
robot.delay (500);
robot.keyRelease (KeyEvent.VK_S);
} captura (AWTException e) {
e.printStackTrace ();
}
}
// LIMPIA PARABRISAS
if (inputLine.equals (“Limpiaparabrisas”)) {
System.out.println (“Limpiaparabrisas enganchados”);
intentar {
Robot robot = nuevo Robot ();
robot.keyPress (KeyEvent.VK_W);
robot.delay (500);
robot.keyRelease (KeyEvent.VK_W);
} captura (AWTException e) {
e.printStackTrace ();
}
}
// LIMITADOR DE VELOCIDAD DE PIT
if (inputLine.equals (“Limitador de velocidad en boxes”)) {
System.out.println (“Limitador de boxes activado”);
intentar {
Robot robot = nuevo Robot ();
robot.keyPress (KeyEvent.VK_P);
robot.delay (500);
robot.keyRelease (KeyEvent.VK_P);
} captura (AWTException e) {
e.printStackTrace ();
}
}
// FAROS DELANTEROS
if (inputLine.equals (“Faros”)) {
System.out.println (“Faros encendidos”);
intentar {
Robot robot = nuevo Robot ();
robot.keyPress (KeyEvent.VK_H);
robot.delay (500);
robot.keyRelease (KeyEvent.VK_H);
} captura (AWTException e) {
e.printStackTrace ();
}
}
} captura (Excepción e) {
System.err.println (e.toString ());
}
}
if (oEvent.getEventType () == SerialPortEvent.DATA_AVAILABLE) {

}
// Ignora todos los demás tipos de eventos, pero debes considerar los otros
// unos.
}

public static void main (String[] args) lanza Exception {
SerialTest main = new SerialTest ();
main.initialize ();
Hilo t = nuevo Hilo () {
public void run () {
// la siguiente línea mantendrá viva esta aplicación durante 1000 segundos,
// esperando que ocurran los eventos y respondiendo a ellos (imprimiendo
// mensajes entrantes a la consola).
intentar {
Thread.sleep (1000000);
} catch (InterruptedException ie) {
}
}
};
t.start ();
System.out.println (“- Iniciado -“);
System.out.println (“”);
}
}

// *******************************************

Como puede ver, hay otros 3 botones conectados. Siempre que Java vea la entrada serial de “Arrancar el motor” , enviará una pulsación de S. La salida…

close