Paso 4: Programación en Java para interpretar serie entrantes y pruebas
Ahora, desnudo conmigo porque sé que a nadie le gusta trabajar con código de otras personas. Es simplemente una mierda. Quizás tenga que modificar la configuración de canal COM, paridad, bits de parada y velocidad en baudios (datos) en el código (que puede ser determinado por el administrador de dispositivos pero debe ser el mismo que el código). El código siguiente funciona con Linux, Mac OS X y Windows. Mi Arduino es por defecto COM1 a 9600b/s. Accidentalmente dejé algún código experimental allí haciendo una GUI pero no afectan a nada así que intento hacerle entender algunas de las importaciones de la biblioteca. La carpeta de SerialTest también se une para referencia.
// *********************************************
Import java.awt.AWTException;
Import java.awt.Robot;
importación java.awt.event.KeyEvent;
importación java.io.BufferedReader;
importación java.io.InputStreamReader;
flujo de importación;
Import gnu.io.CommPortIdentifier;
Import gnu.io.SerialPort;
Import gnu.io.SerialPortEvent;
Import gnu.io.SerialPortEventListener;
importación de java.util.Enumeration;
Import javax.swing.*;
Import javax.swing.event.*;
Import java.awt.*;
Import java.awt.event.*;
Import javax.swing.JFrame;
Import java.awt.Color;
clase pública SerialTest implementa SerialPortEventListener {}
SerialPort serialPort;
/ ** El puerto normalmente vamos a usar. */
Cadena final estático privado PORT_NAMES [] = {"/dev/tty.usbserial-A9007UX1", / / Mac OS X
"/ dev/ttyUSB0", / / Linux
"COM1", / / Windows
};
/**
* Un BufferedReader que será alimentada por un InputStreamReader convierte la
* bytes a caracteres que la página de códigos de resultados mostrado independiente
*/
privado BufferedReader entrada;
/ ** La secuencia de salida al puerto * /
privado OutputStream salida;
/ ** Milisegundos para bloquear esperando puerto abierto * /
int final estático privado para TIME_OUT = 2000;
/ ** Por defecto bits por segundo para puerto COM. */
int final estática privada DATA_RATE = 9600;
público vacío initialize() {}
CommPortIdentifier portId = null;
Enumeración portEnum = CommPortIdentifier.getPortIdentifiers();
En primer lugar, encontrar una instancia de puerto serie como se establece en PORT_NAMES.
mientras (portEnum.hasMoreElements()) {}
CommPortIdentifier currPortId = portEnum (CommPortIdentifier)
.nextElement();
para (String portName: PORT_NAMES) {}
Si (currPortId.getName().equals(portName)) {}
portId = currPortId;
rotura;
}
}
}
System.out.println ("ID de puerto:");
System.out.println(portId);
System.out.println("");
Si (portId == null) {}
System.out.println ("no pudo encontrar COM puerto.");
retorno;
}
trate de {}
abrir puerto serie y utilizar el nombre de la clase para el nombre de aplicación.
serialPort = portId.open(this.getClass().getName() (SerialPort),
PARA TIME_OUT);
parámetros del puerto sistema
serialPort.setSerialPortParams (DATA_RATE, SerialPort.DATABITS_8,
SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
abrir los flujos de
entrada = new BufferedReader (new InputStreamReader (
serialPort.getInputStream()));
salida = serialPort.getOutputStream();
Añadir detectores de eventos
serialPort.addEventListener(this);
serialPort.notifyOnDataAvailable(true);
} catch (excepción e) {}
System.err.println(e.ToString());
}
}
/**
* Esto debería llamarse cuando deje de usar el puerto. Esto evitará que
* Puerto de bloqueo en plataformas como Linux.
*/
público sincronizado {} void close()
Si (serialPort! = null) {}
serialPort.removeEventListener();
serialPort.close();
}
}
/**
* Manejar un evento en el puerto serie. Leer los datos e imprimirlo.
*/
público sincronizado void serialEvent(SerialPortEvent oEvent) {}
Si (oEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE) {}
trate de {}
String inputLine = input.readLine();
ARRANQUE DEL MOTOR
Si (inputLine.equals ("Start Engine")) {}
System.out.println ("motor arranque enganchado");
trate de {}
Robot robot = Robot() nuevo;
robot.keyPress(KeyEvent.VK_S);
robot.Delay(500);
robot.keyRelease(KeyEvent.VK_S);
} catch (AWTException e) {}
e.printStackTrace();
}
}
LIMPIADORES DE PARABRISAS
Si (inputLine.equals ("limpiaparabrisas")) {}
System.out.println ("limpiaparabrisas comprometidos");
trate de {}
Robot robot = Robot() nuevo;
robot.keyPress(KeyEvent.VK_W);
robot.Delay(500);
robot.keyRelease(KeyEvent.VK_W);
} catch (AWTException e) {}
e.printStackTrace();
}
}
LIMITADOR DE VELOCIDAD DE HOYO
Si (inputLine.equals "(limitador de la velocidad del pozo del)) {}
System.out.println ("hoyo limitador comprometido");
trate de {}
Robot robot = Robot() nuevo;
robot.keyPress(KeyEvent.VK_P);
robot.Delay(500);
robot.keyRelease(KeyEvent.VK_P);
} catch (AWTException e) {}
e.printStackTrace();
}
}
FAROS
Si (inputLine.equals("Headlights")) {}
System.out.println ("linternas de comprometidos");
trate de {}
Robot robot = Robot() nuevo;
robot.keyPress(KeyEvent.VK_H);
robot.Delay(500);
robot.keyRelease(KeyEvent.VK_H);
} catch (AWTException e) {}
e.printStackTrace();
}
}
} catch (excepción e) {}
System.err.println(e.ToString());
}
}
Si (oEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE) {}
}
Ignorar todos los eventTypes, pero debe tener en cuenta otro
unos.
}
público principal vacío estático (String [] args) tiros excepción {}
SerialTest principal = new SerialTest();
Main.Initialize();
Hilo t = new Thread() {}
público void run() {}
la siguiente línea será mantener esta aplicación durante 1000 segundos,
a la espera de acontecimientos que se produzcan y responder a ellos (impresión
mensajes entrantes a la consola).
trate de {}
Thread.Sleep(1000000);
} catch (InterruptedException ie) {}
}
}
};
t.Start();
System.out.println ("- comenzado-");
System.out.println("");
}
}
// *********************************************
Como se puede ver, hay 3 otros botones enganchadas. Cuando Java ve la entrada serie del "motor del comienzo" , él enviará una pulsación de S. La consola de salida producirá IO. Excepciones en usted pero no el miedo, es corregir comentando por ambas líneas de System.err.println(e.toString()); . Estos errores no interfieren con nada por lo que son nada que preocuparse para comenzar con. Para cambiar lo que cada interruptor, simplemente cambiar las variables que se conseguir escriben en serie en Arduino y cambie las respectivas declaraciones condicionales en Java para cuando recibe esas cadenas serie. Para ver la lista de disponibles comandos para robot en Eclipse, tipo robot. y un poco voluntad de caja pop-up que muestra varias funciones. Robot es sorprendente, que incluso puede asignar para mover el ratón basado en entrada de Arduino.
