Este artículo comparte el código específico para Java para implementar la comunicación en serie para su referencia. El contenido específico es el siguiente
1. Introducción
El programa de comunicación en serie implementado por Java respalda el envío y la recepción de datos hexadecimales.
Código fuente: SerialPortDemo
Las representaciones son las siguientes:
2.RXTXCOMM
Java Serial Communication Dependency Jar PAQUETE RXTXCOMM.JAR
Descargar dirección: http://download.csdn.net/detail/kong_gu_you_lan/9611334
Incluye uso de la versión de 32 bits y 64 bits:
Copie rxtxcomm.jar al directorio java_home/jre/lib/ext;
Copiar rxtxSerial.dll en el directorio java_home/jre/bin;
Copie rxtxparallel.dll en el directorio java_home/jre/bin;
Java_home es la ruta de instalación JDK
3. Gestión de comunicación de puertos en serie
SerialportManager implementa la gestión de la comunicación de puertos serie, incluida la búsqueda de puertos disponibles, la apertura y el cierre del puerto serie, y el envío y la recepción de datos.
paquete com.yang.serialport.manage; import gnu.io.commport; import gnu.io.commportIdidentifier; import gnu.io.nosuchportexception; import gnu.io.portinuseException; import gnu.io.serialport; import gnu.io.serialvententlistener; importar gnu.io.unsuppapporteception; importación de importación; importación; java.io.ioexception; import java.io.inputstream; import java.io.outputstream; import java.util.arrayList; import java.util.enumeration; import java.util.toomAnyListenerSexception; import. com.yang.serialport.exception.portinuse; import com.yang.serialport.exception.readDataFromSerialPortFailure; import com.yang.serialport.Exception.SendDatAtAserialPortFailure; import Com.yang.serialport.Exception.serialportinputTReamCloseFailure; import com.yang.serialport.exception.serialportoutputputStreamCloseFailure; import com.yang.serialport.exception.serialportParameterFailure; import com.yang.serialport.exception.toomAnlisteners;/*** SERIAL PROPER MANEJER Nombres de puerto*/ @SupessWarnings ("" Unchecked ") Public Static Final ArrayList <String> findPort () {// Obtenga todos los puertos seriales disponibles actualmente enumeración <CommportIdentifier> PortList = CommportIdidentifier .GetPortIdidentifiers (); ArrayList <String> PortnamElist = new ArrayList <String> (); // Agregue el nombre del puerto de serie disponible a la lista y devuelva la lista mientras (portList.hasmoreElements ()) {String PortName = PortList.NextElement (). GetName (); portnamelist.add (portname); } return PortnamElist; } /*** Abra el puerto serie** @param portname* Nombre del puerto* @param baudrate* baude tasa* @return objeto de puerto serie* @throws serialportParameterFailure* No se pudo establecer parámetros de puerto serial* @throws noTaserialport* puerto apuntando al dispositivo no es el tipo de puerto serial* @throws singestion* no se ha correspondido el portero* Ocupado*/ public static final Serialport OpenPort (String PortName, int Baudrate) lanza SerialPortParameterFailure, Notaserialport, Nosuchport, Portinuse {try {// Identificar puerto por nombre de puerto CommportIdidentifier Portidentifier = CommportIdidentifier .getPortidentifier (portname); // Abra el puerto, establezca el nombre del puerto y el tiempo de espera (tiempo de tiempo de espera de la operación de apertura) Commport Commport = PortIdentifier.open (Portname, 2000); // Determinar si se trata de un puerto serie if (Commport instanceOf Serialport) {Serialport Serialport = (Serialport) Commport; Pruebe {// Establezca la tasa de baudios y otros parámetros del puerto serie Serialport.SetSerialPortParams (Baudrate, Serialport.databits_8, Serialport.stopbits_1, serialport.parity_none); } Catch (UnsupportedComMoperationException e) {tirar nueva SerialPortParameterFailure (); } return serialport; } else {// no el puerto serie tira nueva notaSerialPort (); }} Catch (nosuchportException e1) {lanzar new nosuchport (); } Catch (PortInUseException e2) {Throw New PortInuse (); }} / *** Cierre el puerto de serie** @param serialport* objeto de puerto serie para estar cerrado* / public static void ClosePort (Serialport Serialport) {if (serialport! = Null) {serialport.close (); Serialport = nulo; }} / *** Enviar datos al puerto serie** @param serialport* objeto de puerto serie* @param orden* Los datos se enviarán* @throws sendDatatoserialportfailure* No se pudo enviar datos al puerto serie* @throws SerialportOutputputCeFail* Cerrar el error de transmisión de salida del objeto de sierial* / Public static void void void sendtoport (serialportsportoil,, cierre, cierre, cierre el error de transmisión de salida). lanza sendDatatoserialPortFailure, SerialPortOutputStreamCloseFailure {outputStream out = null; intente {out = serialport.getOutputStream (); out.write (orden); out.flush (); } Catch (ioException e) {tire nuevo sendDatatoserialPortFailure (); } finalmente {try {if (out! = null) {out.close (); out = nulo; }} Catch (ioException e) {tire nuevo serialportOutputStreamCloseFailure (); }}} / *** Leer datos del puerto serie** @param serialport* El objeto Serialport con la conexión actualmente establecida* @return los datos read* @throws readDataFromSerialPortfailure* Un error ocurrió al leer datos del puerto serial* @throws serial serialputstreamCloseFailure* un error cuando se produjo cuando se produjo el objeto de puerto de serial* / Public stream* / público static staticin ReadFromPort (Serialport Serialport) arroja readDataFromserialPortFailure, SerialportInputStreamCloseFailure {inputStream in = null; byte [] bytes = null; intente {in = serialport.getInputStream (); // Obtener la longitud de datos int en el buffer bufflenth = in.available (); while (Bufflenth! = 0) {// Inicializa la matriz de bytes a la longitud de los datos en los bytes de búfer = new Byte [Bufflenth]; in.read (bytes); bufflenth = in.available (); }} catch (ioException e) {tire readDataFromSerialPortFailure (); } finalmente {try {if (in! = null) {in.close (); in = nulo; }} Catch (ioException e) {tire nuevo serialportInputStreamCloseFailure (); }} bytes de retorno; } / ** * Agregue el oyente * * @param puerto * objeto de puerto serie * @param oyente * oyente de puerto serie * @throws toomanyListeners * toomanyListeners * toomanyListener Toos objetos de clase de escucha * / public static void addListener (puerto serial, serialportevententernener listos) lanzados toomanylistener {try {//////////////////// / oyente oyente de la oración) Port.AdDeventListener (oyente); // Establezca el hilo de recepción de escucha de activación cuando llegan los datos Port.notifyondataAVailable (verdadero); // Establezca el hilo de interrupción de activación cuando la comunicación se interrumpe el puerto. NotifyOnbreakInterrupts (verdadero); } Catch (ToomanyListeneReSexception e) {arrojar nuevos toomanylisteners (); }}}4. Programa de ventana principal
/ * * Mainframe.java * * creado el 2016.8.19 */paquete com.yang.serialport.ui; import gnu.io.serialport; import gnu.io.serialportevent; import gnu.io.serialportEventListener; importar.awt.color; java.awt.event.ActionEvent; import java.awt.event.actionListener; import java.util.list; import javax.swing.bordfactory; import javax.swing.jbutton; import javax.swing.jcomboBox; import javax.swing.jframe; import javax.swing.jlabel; import; javax.swing.jpanel; import javax.swing.jscrollpane; import javax.swing.jtextarea; import javax.swing.jtextfield; import com.yang.serialport.exception.nosuchport; import.yang.serialport.exception.Notaserialport; import Comm.SerialPort.Except.Exception. com.yang.serialport.exception.senddatatoserialportfailure; import com.yang.serialport.exception.serialportoutputputstreamCloseFailure; import com.yang.serialport com.yang.serialport.manage.serialportManager; import com.yang.serialport.utils.byteutils; import com.yang.serialport.utils.showutils;/*** interfaz principal** @author yangle*/public / *** Altura de la interfaz del programa*/ public static final int alta = 360; private jtexTarea dataView = new JTextArea (); Private JSCrollPane scrolllDataview = new JScrollPane (DataView); // Panel de configuración del puerto serie Privado JPanel SerialPortpanel = new JPanel (); privado jlabel serialportlabel = new JLabel ("puerto serie"); privado jlabel baudratelabel = new Jlabel ("Baudrate"); private jComboBox comschoice = new JComboBox (); privado jComboBox BaudrateChoice = new JComboBox (); // Panel de operación privado jpanel operatePanel = new JPanel (); privado jtextfield datainput = new JTextField (); Private JButton SerialPortOperate = new JButton ("Open Serial Port"); private jbutton sendData = new JButton ("Enviar datos"); Lista privada <String> CommList = NULL; PRIVADO SERIALPORT SERIALPORT; público mainframe () {initView (); initComponents (); ActionListener (); initData (); } private void initView () {// Cierre el programa setDefaultCloseOperation (javax.swing.windowconstants.exit_on_close); // Prohibir la maximización de la ventana setResizable (falso); // Establecer la ventana del programa en el punto central p = gráficoNenvironment.getLocalGraphicSenVironment () .getCenterPoint (); SetBounds (PX - ancho / 2, py - altura / 2, ancho, altura); this.setLayout (nulo); settitle ("comunicación en serie"); } private void initComponents () {// Data Display DataView.SetFocusable (False); scrollldataview.setBounds (10, 10, 475, 200); agregar (scrolllDataview); // SerialPortpanel.setBorder (BorderFactory.CreateTitledBorder ("SerialPortset")); SerialPortpanel.setBounds (10, 220, 170, 100); SerialPortpanel.setLayout (nulo); Agregar (SerialPortPanel); SerialPortLabel.setForeground (color.gray); SerialPortLabel.setBounds (10, 25, 40, 20); SerialPortpanel.add (SerialPortLabel); comChoice.setFocusable (falso); comChoice.setBounds (60, 25, 100, 20); SerialPortpanel.add (comChoice); Baudratelabel.setForeGround (color.gray); Baudratelabel.setBounds (10, 60, 40, 20); SerialPortpanel.add (Baudratelabel); BaudrateChoice.setFocusable (falso); Baudratechoice.setBounds (60, 60, 100, 20); SerialPortpanel.add (BaudrateChoice); // Operación operatepanel.setBounds (200, 220, 285, 100); operatepanel.setLayout (nulo); add (operatePanel); DataAnput.setBounds (25, 25, 235, 20); operatepanel.add (datainput); SerialPortOperate.setFocusable (falso); SerialPortOperate.setBounds (45, 60, 90, 20); operatepanel.add (SerialPortOperate); sendData.setFocusable (falso); sendData.setBounds (155, 60, 90, 20); operatepanel.add (sendData); } @Suppleswarnings ("sin verificar") private void initData () {commList = serialportManager.findport (); // Verifique si hay un puerto serie, agrégalo a la opción if (commList == NULL || CommList.Size () <1) {showUtils.WarningMessage ("¡No se encontró un puerto serie válido!"); } else {para (String S: CommList) {comChoice.Additem (s); }} BaudrateChoice.additem ("9600"); Baudratechoice.additem ("19200"); Baudratechoice.additem ("38400"); Baudratechoice.additem ("57600"); Baudratechoice.additem ("115200"); } private void actionListener () {SerialPortoPerate.addactionListener (new ActionListener () {@Override public void ActionPerformed (ActionEvent E) {if ("Open Serial Port" .Equals (SerialPortOperate.gettext ()) && SerialPort == null) {OpenSerialPort (E);} más }); sendData.AddActionListener (new ActionListener () {@Override public void ActionPerformed (ActionEvent e) {sendData (e);}}); } / *** Abrir puerto serie** @param evt* haga clic en evento* / private void OpenSerialPort (java.awt.event.actionEvent evt) {// Obtener la cadena de nombre del puerto serie commname = (string) comChoice.getSelectedItem (); // Obtener la velocidad de baudio int baudrate = 9600; Cadena bps = (string) BaudrateChoice.getSelectedItem (); baudRate = Integer.ParseInt (BPS); // verifique si el nombre del puerto serie es correcto si (commname == null || commname.equals ("")) {showUtils.WarningMessage ("¡No se encontró un puerto serie válido!"); } else {try {serialport = serialportManager.openport (Commname, Baudrate); if (serialport! = null) {dataView.settext ("Serialport está activado" + "/r/n"); SerialPortOperate.setText ("Cerrar Serialport"); }} Catch (SerialPortParameterFailure e) {E.PrintStackTrace (); } catch (nosuchport e) {E.PrintStackTrace (); } catch (Portinuse E) {E.PrintStackTrace (); ShowUtils.WarningMessage ("¡El puerto serie ha sido ocupado!"); }} try {SerialPortManager.addListener (Serialport, new SerialListener ()); } catch (ToomanyListeners e) {E.PrintStackTrace (); }} / *** Cierre el puerto serie** @param evt* haga clic en evento* / private void searserialport (java.awt.event.actionEvent evt) {SerialportManager.ClosePort (Serialport); dataview.settext ("El puerto serie está cerrado" + "/r/n"); SerialPortOperate.settext ("Open Serial Port"); } / *** Enviar datos** @param evt* Haga clic en evento* / private void sendData (java.awt.event.actionEvent evt) {// Ingrese caracteres hexadecimales directamente en el cuadro de entrada, la longitud debe ser incluso string data = datainput.gettext (). ToString (); intente {SerialPortManager.SendToport (Serialport, byteutils.hexstr2byte (data)); } catch (sendDatatoserialPortFailure e) {E.PrintStackTrace (); } Catch (SerialPortOutputStreamCloseFailure e) {E.PrintStackTrace (); }} La clase privada SerialListener implementa SerialPortEventListener { / *** manejar eventos de puerto serial monitoreado* / public void serialevent (SerialPortEvent SerialPorteVent) {switch (serialportEvent.getEventType ()) {case serialporteVent.bi: // 10 comunicación interrupción showutils. romper; caso SerialPorteVent.oe: // 7 Overflow (Overflow) Error Case SerialPortEvent.fe: // 9 Error de marco Case SERIALPORTEVENT.PE: // 8 Error de paridad Caso SerialPortEvent.cd: // 6 Detección de transporte Case SerialPortEvent.cts: // 3 Clear Data para enviar Case SerialPortEvent.dsrr: // 4 Los datos se envían a los datos a los datos que se envían a los datos a los datos a los datos que se sentarán a los datos. Caso de indicación SerialPortEvent.output_buffer_empty: // 2 El búfer de salida se ha eliminado el ruptura; case serialportEvent.data_available: // 1 Los datos disponibles existen en el byte del puerto serie [] data = null; Pruebe {if (serialport == null) {showUtils.errormessage ("¡El objeto del puerto serie está vacío! } else {// Leer datos de datos de puerto serie = SerialPortManager.readFromPort (SerialPort); dataview.append (byteutils.bytearrayToHexString (data, true) + "/r/n"); }} Catch (Exception e) {showUtils.errormessage (e.ToString ()); // Salir del sistema después de mostrar un error cuando ocurre un error de lectura System.exit (0); } romper; }}} public static void main (string args []) {java.awt.eventqueue.invokelater (new runnable () {public void run () {new mainframe (). setVisible (true);}}); }}5. Escritado al final
Dirección de descarga del código fuente: Serialportdemo
Los estudiantes son bienvenidos a quejarse y comentar. Si cree que este blog es útil para usted, deje un mensaje o dale un comentario (＾－＾)
Gracias: Escribir herramientas de comunicación en serie basadas en Java
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.