急求:JAVA读写串口的操作方法,试了几个都没反应啊,急啊.........分再加多少都行.

Question

我没用超级终端的时候,用包里面的例子里的SimpleWrite在COM2循环不断的写,在COM1用SimpleRead也是读不到,我已经用RS-232线将两个串口连接起来了

Answer 1

已经正确配置了,程序已经可以扫描到机器上的四个PORT了.就是读的时候读不到数据,是不是直接用电缆将COM1和COM2接起来就行了?我是在一台机器上.还有,COMM这个包能不能处理RS-485的PORT?

Answer 2

这是我读和写的代码:
写:
import java.io.*;
import java.util.*;
import javax.comm.*;public class SimpleWrite {
    static CommPortIdentifier myPort;
    static String messageString = "Hello, world!\n";
    static SerialPort serialPort;
    static OutputStream outputStream;    public static void main(String[] args) {
     try{
     myPort = CommPortIdentifier.getPortIdentifier("COM1");
    }catch(Exception e){
     e.printStackTrace();
    }        try{
        serialPort = (SerialPort)myPort.open("SimpleWriteApp", 2000);
        } catch (PortInUseException e) {
         e.printStackTrace();
        }
        try{
            outputStream = serialPort.getOutputStream();
        } catch (IOException e) {
         e.printStackTrace();
        }
        try {
            serialPort.setSerialPortParams(9600,
                            SerialPort.DATABITS_8,
                            SerialPort.STOPBITS_1,
                            SerialPort.PARITY_NONE);
        } catch (UnsupportedCommOperationException e) {}
        try {
                        outputStream.write(messageString.getBytes());
                        System.out.println ("写入" + myPort.getName() + "信息成功");
        } catch (IOException e) {
         e.printStackTrace();
        }
   }
}
-------------------------------------------------------
这是读端口代码:
import java.io.*;
import java.util.*;
import javax.comm.*;public class SimpleRead implements Runnable, SerialPortEventListener {
    static CommPortIdentifier portId;
    
    InputStream inputStream;
    SerialPort serialPort;
    Thread readThread;    public static void main(String[] args) {
     try{
        portId = CommPortIdentifier.getPortIdentifier("COM2");
     }catch(Exception e){
      e.printStackTrace();
     }
        SimpleRead reader = new SimpleRead();
        System.out.println ("读到的信息:");
        int i;
        try{
        while((i = reader.inputStream.read()) != -1){
          System.out.println ((char)i);
         }
        }catch(Exception e){
         e.printStackTrace();
        }
    }    public SimpleRead() {
        try {
            serialPort = (SerialPort) portId.open("SimpleReadApp", 2000);
        } catch (PortInUseException e) {
         e.printStackTrace();
        }
        try {
            inputStream = serialPort.getInputStream();
        } catch (IOException e) {
         e.printStackTrace();
        }
try {
            serialPort.addEventListener(this);
} catch (TooManyListenersException e) {}
        serialPort.notifyOnDataAvailable(true);
        try {
            serialPort.setSerialPortParams(9600,
                SerialPort.DATABITS_8,
                SerialPort.STOPBITS_1,
                SerialPort.PARITY_NONE);
        } catch (UnsupportedCommOperationException e) {}
        readThread = new Thread(this);
        readThread.start();
    }    public void run() {
        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {}
    }    public void serialEvent(SerialPortEvent event) {
        switch(event.getEventType()) {
        case SerialPortEvent.BI:
        case SerialPortEvent.OE:
        case SerialPortEvent.FE:
        case SerialPortEvent.PE:
        case SerialPortEvent.CD:
        case SerialPortEvent.CTS:
        case SerialPortEvent.DSR:
        case SerialPortEvent.RI:
        case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
            break;
        case SerialPortEvent.DATA_AVAILABLE:
            byte[] readBuffer = new byte[20];            try {
                while (inputStream.available() > 0) {
                    int numBytes = inputStream.read(readBuffer);
                }
                System.out.print(new String(readBuffer));
            } catch (IOException e) {}
            break;
        }
    }
}在COM1上写,在COM2读,两个端口用串口线直接连接起来了,写的程序运行完毕了,打印出来了(写入COM1 信息成功).可读的程序一直停在read()那里,什么都没读出来,我已经试过在写的程序用一个无限循环不停的写,结果也一样.

Answer 3

com1 com2连接的时候 油三根数据线  
        2-----3
        3-----2
        5-----5

Answer 4

我是买的一根标准的串口线,两头是COM接口的线直接相连的.另外,对上面的读的程序中的事件监听这一段不太理解,是不是一有数据来,那个方法里就会处理?
public void serialEvent(SerialPortEvent event) {
        switch(event.getEventType()) {
        case SerialPortEvent.BI:
        case SerialPortEvent.OE:
        case SerialPortEvent.FE:
        case SerialPortEvent.PE:
        case SerialPortEvent.CD:
        case SerialPortEvent.CTS:
        case SerialPortEvent.DSR:
        case SerialPortEvent.RI:
        case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
            break;
        case SerialPortEvent.DATA_AVAILABLE:
            byte[] readBuffer = new byte[20];            try {
                while (inputStream.available() > 0) {
                    int numBytes = inputStream.read(readBuffer);
                }
                System.out.print(new String(readBuffer));
            } catch (IOException e) {}
            break;
        }
    }

Answer 5

SerialPortEventListener 会监听串口，只要串口有数据，就会触发一个SerialPortEvent 事件，执行serialEvent（SerialPortEvent event）方法

Answer 6

各位老兄帮我分析分析,我用上面的代码,用一根线连起一台机的COM1和COM2,为什么在读的时候读不到数据啊????是代码有问题还是硬件的连接有问题了?急啊..........谢谢!

Answer 7

蒋的东西不是很好用，我以前做过，现在都忘记了。
还不如直接参考sun的东西。

Answer 8

我上面给的两个例子就是SUN的例子里的代码.现在就是读不到数据啊,好郁闷,不知道程序哪里出错,或者是我测试的方法不对,也不知怎么个测试法.怎么往COM口传送数据......

Answer 9

试试在
outputStream.write(messageString.getBytes());
之后加上
outputStream.flush();俺没试过，不知道行不行。

Answer 10

,非常感谢老兄.
硬件问题其实我已经试过了好几台机了,本想用超级终端来试试,可那个东西搞了半天不知怎么发消息,上网查资料都是用超级终端来连接MODEM的,不是我的串口线的这种.现在这样直接用我的上面的程序去试,就搞不清是程序的问题还是连接的问题了.不过我看到CSDN上以前很多老兄都搞过这个问题,都说一下就搞定了,看来搞定它问题应该是不太大的,只是我现在不知被拌在哪一块,怎么都过不去,郁闷.另外,哪位老兄知不知道,这个包支不支持RS-485的串口啊?这方面的资料我也没查到.

Answer 11

不好意思，才看到短消息！！：）
读端口的程序我做过，不过没有象你那样用数据线做测试
我是通过端口操作的GPRS Modem 发短信

Answer 12

TO bonwei(阿邦) :
你的邮件我收到了,谢谢.你发的那个串口调试器我昨天也下载过一个用过了.
那种串口调试的工具我试了几个,不过没有一个试出个正常的结果.那种工具是不是这样的:
在COM1端口启动一个调试程序,在COM2端口启动另一个调试程序,用线将COM1和COM2连接起来,然后在COM1口的程序发出信息,COM2口的程序就能自动的立即收到?我是什么信息都没收到...
感谢另外几位老兄的回贴,现在最郁闷的不知怎么个调试法,第一步都没通过,所以程序的别的问题也还不知道...........

Answer 13

你看看你的包放好了没有。也就是配置的问题。我刚开始的时候也是按下载的说明将那些包放在相应的位置。可是，这是没有用的。要放在Windows目录下的Java什么目录下吧。反正网上有资料。你找一下吧。我好久没用这个了。

Answer 14

如果包没放好,那肯定不会检测出来机器上的那些串口和并口吧,我觉得应该包是没问题的.我就想问问各位以前做过的老兄,你们的调试方法是怎么的?是不是用一线将COM1和COM2连接起来这种方法来调试的?这种方法要注意什么问题?

Answer 15

TO bonwei(阿邦) 兄我现在也是这样在测试,试了好几台机,一边用我上面的两个程序或读或写,一边用串品调试程序在或读或写,可就是不出东西.难道是我的那根串口线有问题吗?我中午再去买机线试试看,阿邦兄再帮我看看我上面的贴出来的两个读写串口的代码有没有问题了,或者把你的测试用的读写串口的代码发一份给我看看,非常感谢.这个问题搞定后,我再开一个100分贴给你,谢谢!

Answer 16

to  cql0007(蓝月) 
我觉得可能不是硬件的问题，我写了一段代码，使用一个线程向COM1写，一个线程从COM1读，一样的读不出来。我COM1连接的是手机。但是用超级终端读写都没问题。不知道是什么原因

Answer 17

超级终端怎么个读写法?我试了很久的那玩意,启动后那个界面上不能输入信息,在网上查资料都是说超级终端和MODEM连接的,和COM口连接就是没看到.我已经换了一条COM线了,再试试看

Answer 18

这个我也不怎么清楚！~你看看！
http://www-900.ibm.com/developerWorks/cn/java/j-i-barcd/index.shtml

Answer 19

我不知道你是怎么用我给你的那个程序的，你应该打开两个那个小程序，一个设成com1，一个com2，一边读一边写，这样来测试硬件联线啊

Answer 20

没错,我就是打开两个,一个端口设成COM1,一个设成COM2,一个按"开始发送＂，可以看到那个下面有一行行的数据被打印出来，应该就是被发送的数据吧，但另外一个小程序没见到接收到有数据啊．老兄，方便就留个ＭＳＮ如何啊？

Answer 21

如果说这样子都没有数据的话，那还是要从硬件上找问题我的msn是[email protected]

Answer 22

肯定是硬件问题
先测试一下两个串口是不是能够正常收发你老人家就不能弄个MODEM吗？！！

Answer 23

package serial;
    import java.io.*;
    import java.util.*;
    import javax.comm.*;
    /**
     *
     * This bean provides some basic functions to implement full dulplex
     * information exchange through the srial port.
     *
     */
    public class SerialBean
    {
        static String PortName;
        CommPortIdentifier portId;
        SerialPort serialPort;
        static OutputStream out;
        static InputStream  in;
        SerialBuffer SB;
        ReadSerial   RT;
            /**
             *
             * Constructor
             *
             * @param PortID the ID of the serial to be used. 1 for COM1,
             * 2 for COM2, etc.
             *
             */
            public SerialBean(int PortID)
            {
                PortName = "COM" + PortID;
            }
            /**
             *
             * This function initialize the serial port for communication. It startss a
             * thread which consistently monitors the serial port. Any signal capturred
             * from the serial port is stored into a buffer area.
             *
             */
            public int Initialize()
            {
                int InitSuccess = 1;
                int InitFail    = -1;
            try
            {
                portId = CommPortIdentifier.getPortIdentifier(PortName);
                try
                {
                    serialPort = (SerialPort)
                    portId.open("Serial_Communication", 2000);
                } catch (PortInUseException e)
                {
                    return InitFail;
                }
                //Use InputStream in to read from the serial port, and OutputStream
                //out to write to the serial port.
                try
                {
                    in  = serialPort.getInputStream();
                    out = serialPort.getOutputStream();
                } catch (IOException e)
                {
                    return InitFail;
                }
                //Initialize the communication parameters to 9600, 8, 1, none.
                try
                {
                     serialPort.setSerialPortParams(9600,
                                SerialPort.DATABITS_8,
                                SerialPort.STOPBITS_1,
                                SerialPort.PARITY_NONE);
                } catch (UnsupportedCommOperationException e)
                {
                    return InitFail;
                }
            } catch (NoSuchPortException e)
            {
                return InitFail;
            }
            // when successfully open the serial port,  create a new serial buffer,
            // then create a thread that consistently accepts incoming signals from
            // the serial port. Incoming signals are stored in the serial buffer.
            SB = new SerialBuffer();
            RT = new ReadSerial(SB, in);
            RT.start();
            // return success information
            return InitSuccess;
            }
            /**
             *
             * This function returns a string with a certain length from the incomin
             * messages.
             *
             * @param Length The length of the string to be returned.
             *
             */
            public String ReadPort(int Length)
            {
                String Msg;
                Msg = SB.GetMsg(Length);
                return Msg;
            }
            /**
             *
             * This function sends a message through the serial port.
             *
             * @param Msg The string to be sent.
             *
             */
            public void WritePort(String Msg)
            {
                int c;
                try
                {
                    for (int i = 0; i < Msg.length(); i++)
                        out.write(Msg.charAt(i));
                } catch (IOException e)  {}
            }
            /**
             *
             * This function closes the serial port in use.
             *
             */
            public void ClosePort()
            {
                RT.stop();
                serialPort.close();
            }
    }

Answer 24

package serial;
    /**
     *
     * This class implements the buffer area to store incoming data from the serial
     * port.
     *
     */
    public class SerialBuffer
    {
        private String Content = "";
        private String CurrentMsg, TempContent;
        private boolean available = false;
        private int LengthNeeded = 1;
            /**
             *
             * This function returns a string with a certain length from the incomin
             * messages.
             *
             * @param Length The length of the string to be returned.
             *
             */
        public synchronized String GetMsg(int Length)
        {
            LengthNeeded = Length;
            notifyAll();
            if (LengthNeeded > Content.length())
            {
                available = false;
                while (available == false)
                {
                    try
                    {
                        wait();
                    } catch (InterruptedException e) { }
                }
            }
            CurrentMsg  = Content.substring(0, LengthNeeded);
            TempContent = Content.substring(LengthNeeded);
            Content = TempContent;
            LengthNeeded = 1;
            notifyAll();
            return CurrentMsg;
        }
            /**
             *
             * This function stores a character captured from the serial port to the
             * buffer area.
             *
             * @param t The char value of the character to be stored.
             *
             */
        public synchronized void PutChar(int c)
        {
            Character d = new Character((char) c);
            Content = Content.concat(d.toString());
            if (LengthNeeded < Content.length())
            {
                available = true;
            }
            notifyAll();
        }
    }

Answer 25

package serial;
    import java.io.*;
    /**
     *
     * This class reads message from the specific serial port and save
     * the message to the serial buffer.
     *
     */
    public class ReadSerial extends Thread
    {
        private SerialBuffer ComBuffer;
        private InputStream ComPort;
            /**
             *
             * Constructor
             *
             * @param SB The buffer to save the incoming messages.
             * @param Port The InputStream from the specific serial port.
             *
             */
        public ReadSerial(SerialBuffer SB, InputStream Port)
        {
            ComBuffer = SB;
            ComPort = Port;
        }
        public void run()
        {
            int c;
            try
            {
                while (true)
                {
                    c = ComPort.read();
                    ComBuffer.PutChar(c);
                }
            } catch (IOException e) {}
        }
    }