En utilisant un Arduino Uno R3 comme un contrôleur de jeu (4 / 7 étapes)

Étape 4: Programmation en Java pour interpréter entrant série & tests

Maintenant, nu avec moi parce que je sais que personne n’aime travailler avec le code d’autres personnes. Elle le suce juste. Vous devrez peut-être modifier les paramètres du canal COM, parité, bits d’arrêt et la vitesse de transmission (données) dans le code (qui peut être déterminée par le gestionnaire de périphériques, mais devrait être le même que le code). Le code ci-dessous fonctionne sous Linux, Mac OS X et Windows. Mon Arduino est sur la valeur par défaut de COM1 à 9600b/s. J’ai laissé accidentellement un code expérimental là-dedans tout en faisant un GUI, mais ils n’affectent pas quelque chose d’aussi essayer d’ignorer à comprendre certains des importations en bibliothèque. Le dossier SerialTest est également fixé pour référence.

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

java.awt.AWTException d’importation ;
java.awt.Robot d’importation ;
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 ;
java.util.Enumeration d’importation ;
Import javax.swing.* ;
Import javax.swing.event.* ;
import java.awt.* ;
import java.awt.event.* ;
javax.swing.JFrame d’importation ;
import java.awt.Color ;

/ public class SerialTest implements SerialPortEventListener {}
SerialPort serialPort ;
/ ** Le port nous allons normalement utiliser. */
privé public static final String PORT_NAMES [] = {"/dev/tty.usbserial-A9007UX1", / / Mac OS X
« / dev/ttyUSB0 », / / Linux
« COM1 », / / Windows
};
/**
* Un BufferedReader qui sera alimenté par un InputStreamReader convertissant le
* octets en caractères, rendant la page de codes de résultats affichés indépendant
*/
BufferedReader privé d’entrée ;
/ ** Le flux de sortie au port * /
OutputStream privé de sortie ;
/ ** Millisecondes pour bloquer pendant que vous attendez de port ouvert * /
privé public static final int TIME_OUT = 2000 ;
/ ** Par défaut bits par seconde pour le port COM. */
privé public static final int DATA_RATE = 9600 ;

public void initialize() {}
CommPortIdentifier portId = null ;
Énumération portEnum = CommPortIdentifier.getPortIdentifiers() ;

Tout d’abord, trouver une instance de port série comme indiqué dans PORT_NAMES.
tandis que (portEnum.hasMoreElements()) {}
CommPortIdentifier currPortId = portEnum (CommPortIdentifier)
.nextElement() ;
pour (String portName : PORT_NAMES) {}
Si (currPortId.getName().equals(portName)) {}
portId = currPortId ;
rupture ;
}
}
}
System.out.println ("Port ID:") ;
System.out.println(portId) ;
System.out.println("") ;
Si (portId == null) {}
System.out.println ("Impossible de trouver port COM.") ;
retour ;
}

try {}
ouvrir le port série et utiliser le nom de la classe pour l’appName.
serialPort = portId.open(this.getClass().getName() (SerialPort),
TIME_OUT) ;

paramètres de port jeu
serialPort.setSerialPortParams (DATA_RATE, SerialPort.DATABITS_8,
SerialPort.STOPBITS_1, SerialPort.PARITY_NONE) ;

ouvrir le flux
entrée = nouveau BufferedReader (new InputStreamReader (
serialPort.getInputStream())) ;
sortie = serialPort.getOutputStream() ;

Ajouter des écouteurs d’événements
serialPort.addEventListener(this) ;
serialPort.notifyOnDataAvailable(true) ;
} catch (Exception e) {}
System.Err.println(e.ToString()) ;
}
}

/**
* Il doit être appelé lorsque vous arrêtez d’utiliser le port. Cela permettra d’éviter
* port de verrouillage sur les plateformes comme Linux.
*/
public synchronized void close() {}
Si (serialPort! = null) {}
serialPort.removeEventListener() ;
serialPort.close() ;
}
}

/**
* Gérer un événement sur le port série. Lire les données et l’imprimer.
*/
public synchronized void serialEvent(SerialPortEvent oEvent) {}
Si (oEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE) {}
try {}
String inputLine = input.readLine() ;
DÉMARRAGE DES MOTEURS
Si (inputLine.equals ("Start Engine")) {}
System.out.println ("Engine Start engagé") ;
try {}
Robot robot = new Robot() ;
robot.keyPress(KeyEvent.VK_S) ;
robot.Delay(500) ;
robot.keyRelease(KeyEvent.VK_S) ;
} catch (AWTException e) {}
e.printStackTrace() ;
}
}
ESSUIE-GLACES DE PARE-BRISE
Si (inputLine.equals ("essuie-glace")) {}
System.out.println ("essuie-glaces engagés") ;
try {}
Robot robot = new Robot() ;
robot.keyPress(KeyEvent.VK_W) ;
robot.Delay(500) ;
robot.keyRelease(KeyEvent.VK_W) ;
} catch (AWTException e) {}
e.printStackTrace() ;
}
}
LIMITEUR DE VITESSE DE FOSSE
Si (inputLine.equals ("fosse du limiteur de vitesse")) {}
System.out.println ("Pit limiteur engagé") ;
try {}
Robot robot = new Robot() ;
robot.keyPress(KeyEvent.VK_P) ;
robot.Delay(500) ;
robot.keyRelease(KeyEvent.VK_P) ;
} catch (AWTException e) {}
e.printStackTrace() ;
}
}
PHARES
Si (inputLine.equals("Headlights")) {}
System.out.println ("phares engagés") ;
try {}
Robot robot = new Robot() ;
robot.keyPress(KeyEvent.VK_H) ;
robot.Delay(500) ;
robot.keyRelease(KeyEvent.VK_H) ;
} catch (AWTException e) {}
e.printStackTrace() ;
}
}
} catch (Exception e) {}
System.Err.println(e.ToString()) ;
}
}
Si (oEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE) {}

}
Ignorer tous les autres eventTypes, mais vous devriez considérer l’autre
ones.
}

Public Shared Sub main (String [] args) lève Exception {}
Principal SerialTest = new SerialTest() ;
main.Initialize() ;
Thread t = new Thread() {}
public void run() {}
la ligne suivante gardera en vie ce soft pendant 1000 secondes,
en attendant que les événements se produisent et y répondre (impression
messages entrants à la console).
try {}
Thread.Sleep(1000000) ;
} catch (InterruptedException ie) {}
}
}
};
t.Start() ;
System.out.println ("- en route-") ;
System.out.println("") ;
}
}

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

Comme vous pouvez le voir, il y a 3 autres boutons accrochés. Quand Java voit l’entrée série de "Start Engine" , il enverra une frappe de S. La console de sortie lèvera IO. Exceptions près, à vous, mais ne craignez pas, c’est réparable, en commentant les deux lignes de System.err.println(e.toString()); . Ces erreurs n’interfèrent pas avec n’importe quoi, donc ils ont rien à craindre dans un premier temps. Pour changer ce que chaque commutateur, simplement changer les variables s’écrites dans de la série dans l’Arduino et les instructions conditionnelles respectives en Java pour lorsqu’il reçoit les chaînes de la série. Pour voir la liste à la disposition des commandes pour robot dans Eclipse, boîte un peu de volonté et de type robot. pop-up montrant diverses fonctions. Le robot est incroyable, que vous pouvez même attribuer à déplacer la souris basée sur l’entrée de l’Arduino.