小弟是java新手,最近要做一个项目,就是要从RS232接口上读取电子称上的数据,然后打印成重量标签。
不知道怎么从RS232接口读取数据和调用打印机接口程序.
希望各位大哥指点,有这方面资料的,发到我邮箱:[email protected] 谢谢!

解决方案 »

  1.   

    package serial;
    import gnu.io.SerialPort;
    import java.util.HashMap;
    public class CommTest { public static void main(String[] args) {
      HashMap<String, Comparable> params = new HashMap<String, Comparable>();
      params.put(SerialReader.PARAMS_PORT, "COM8"); // 端口名称
      params.put(SerialReader.PARAMS_RATE, 9600); // 波特率
      params.put(SerialReader.PARAMS_TIMEOUT, 1000); // 设备超时时间 1秒
      params.put(SerialReader.PARAMS_DELAY, 200); // 端口数据准备时间 1秒
      params.put(SerialReader.PARAMS_DATABITS, SerialPort.DATABITS_8); // 数据位
      params.put(SerialReader.PARAMS_STOPBITS, SerialPort.STOPBITS_1); // 停止位
      params.put(SerialReader.PARAMS_PARITY, SerialPort.PARITY_NONE); // 无奇偶校验
      SerialReader sr = new SerialReader(params);
      CommDataObserver bob = new CommDataObserver("bob");
      CommDataObserver joe = new CommDataObserver("joe");
      sr.addObserver(joe);
      sr.addObserver(bob);
     }
    }
     
    ---------------- 2 -----------------
    package serial;
    import gnu.io.CommPort;
    import gnu.io.CommPortIdentifier;
    import gnu.io.NoSuchPortException;
    import gnu.io.PortInUseException;
    import gnu.io.SerialPort;
    import gnu.io.SerialPortEvent;
    import gnu.io.SerialPortEventListener;
    import gnu.io.UnsupportedCommOperationException;
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.Enumeration;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Observable;
    import java.util.TooManyListenersException;
    /**
     * 串口数据读取类,用于windows的串口数据读取
     *
     */
    public class SerialReader extends Observable implements Runnable, SerialPortEventListener {
     static CommPortIdentifier portId;
     int delayRead = 200;
     int numBytes; // buffer中的实际数据字节数
     private static byte[] readBuffer = new byte[4096]; // 4k的buffer空间,缓存串口读入的数据
     static Enumeration portList;
     InputStream inputStream;
     SerialPort serialPort;
     HashMap serialParams;
     // 端口读入数据事件触发后,等待n毫秒后再读取,以便让数据一次性读完
     public static final String PARAMS_DELAY = "delay read"; // 延时等待端口数据准备的时间
     public static final String PARAMS_TIMEOUT = "timeout"; // 超时时间
     public static final String PARAMS_PORT = "port name"; // 端口名称
     public static final String PARAMS_DATABITS = "data bits"; // 数据位
     public static final String PARAMS_STOPBITS = "stop bits"; // 停止位
     public static final String PARAMS_PARITY = "parity"; // 奇偶校验
     public static final String PARAMS_RATE = "rate"; // 波特率
     /**
      * 初始化端口操作的参数.
      *
      *
      * @see
      */
     public SerialReader(HashMap params) {
      serialParams = params;
      init();
     }
     private void init() {
      try {
       // 参数初始化
       int timeout = Integer.parseInt(serialParams.get(PARAMS_TIMEOUT).toString());
       int rate = Integer.parseInt(serialParams.get(PARAMS_RATE).toString());
       int dataBits = Integer.parseInt(serialParams.get(PARAMS_DATABITS).toString());
       int stopBits = Integer.parseInt(serialParams.get(PARAMS_STOPBITS).toString());
       int parity = Integer.parseInt(serialParams.get(PARAMS_PARITY).toString());
       delayRead = Integer.parseInt(serialParams.get(PARAMS_DELAY).toString());
       String port = serialParams.get(PARAMS_PORT).toString();
       // 打开端口
       portId = CommPortIdentifier.getPortIdentifier(port);
       serialPort = (SerialPort) portId.open("SerialReader", timeout);
       inputStream = serialPort.getInputStream();
       serialPort.addEventListener(this);
       serialPort.notifyOnDataAvailable(true);
       serialPort.setSerialPortParams(rate, dataBits, stopBits, parity);
      } catch (PortInUseException e) {
       System.out.println("端口已经被占用!");
       e.printStackTrace();
      } catch (TooManyListenersException e) {
       System.out.println("端口监听者过多!");
       e.printStackTrace();
      } catch (UnsupportedCommOperationException e) {
       System.out.println("端口操作命令不支持!");
       e.printStackTrace();
      } catch (NoSuchPortException e) {
       System.out.println("端口不存在!");
       e.printStackTrace();
      } catch (IOException e) {
       e.printStackTrace();
      }
      Thread readThread = new Thread(this);
      readThread.start();
     }
     /**
      * Method declaration
      *
      *
      * @see
      */
     public void run() {
      try {
       Thread.sleep(100);
      } catch (InterruptedException e) {
      }
     }
     /**
      * Method declaration
      *
      *
      * @param event
      *
      * @see
      */
     public void serialEvent(SerialPortEvent event) {
      try {
       // 等待1秒钟让串口把数据全部接收后在处理
       Thread.sleep(delayRead);
       System.out.print("serialEvent[" + event.getEventType() + "]    ");
      } catch (InterruptedException e) {
       e.printStackTrace();
      }
      switch (event.getEventType()) {
      case SerialPortEvent.BI: // 10
      case SerialPortEvent.OE: // 7
      case SerialPortEvent.FE: // 9
      case SerialPortEvent.PE: // 8
      case SerialPortEvent.CD: // 6
      case SerialPortEvent.CTS: // 3
      case SerialPortEvent.DSR: // 4
      case SerialPortEvent.RI: // 5
      case SerialPortEvent.OUTPUT_BUFFER_EMPTY: // 2
       break;
      case SerialPortEvent.DATA_AVAILABLE: // 1
       try {
        // 多次读取,将所有数据读入
        // while (inputStream.available() > 0) {
        // numBytes = inputStream.read(readBuffer);
        // }
        numBytes = inputStream.read(readBuffer);
        changeMessage(readBuffer, numBytes);
       } catch (IOException e) {
        e.printStackTrace();
       }
       break;
      }
     }
     // 通过observer pattern将收到的数据发送给observer
     // 将buffer中的空字节删除后再发送更新消息,通知观察者
     public void changeMessage(byte[] message, int length) {
      setChanged();
      byte[] temp = new byte[length];
      System.arraycopy(message, 0, temp, 0, length);
      // System.out.println("msg[" + numBytes + "]: [" + new String(temp) + "]");
      notifyObservers(temp);
     }
     static void listPorts() {
      Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();
      while (portEnum.hasMoreElements()) {
       CommPortIdentifier portIdentifier = (CommPortIdentifier) portEnum.nextElement();
       System.out.println(portIdentifier.getName() + " - "
         + getPortTypeName(portIdentifier.getPortType()));
      }
     }
     static String getPortTypeName(int portType) {
      switch (portType) {
      case CommPortIdentifier.PORT_I2C:
       return "I2C";
      case CommPortIdentifier.PORT_PARALLEL:
       return "Parallel";
      case CommPortIdentifier.PORT_RAW:
       return "Raw";
      case CommPortIdentifier.PORT_RS485:
       return "RS485";
      case CommPortIdentifier.PORT_SERIAL:
       return "Serial";
      default:
       return "unknown type";
      }
     }
     /**
      * @return A HashSet containing the CommPortIdentifier for all serial ports that are not
      *         currently being used.
      */
     public static HashSet<CommPortIdentifier> getAvailableSerialPorts() {
      HashSet<CommPortIdentifier> h = new HashSet<CommPortIdentifier>();
      Enumeration thePorts = CommPortIdentifier.getPortIdentifiers();
      while (thePorts.hasMoreElements()) {
       CommPortIdentifier com = (CommPortIdentifier) thePorts.nextElement();
       switch (com.getPortType()) {
       case CommPortIdentifier.PORT_SERIAL:
        try {
         CommPort thePort = com.open("CommUtil", 50);
         thePort.close();
         h.add(com);
        } catch (PortInUseException e) {
         System.out.println("Port, " + com.getName() + ", is in use.");
        } catch (Exception e) {
         System.out.println("Failed to open port " + com.getName() + e);
        }
       }
      }
      return h;
     }
    }
     
    ---------- 3 -----------------
    package serial;
    import java.util.Observable;
    import java.util.Observer;
    class CommDataObserver implements Observer {
     String name;
     public CommDataObserver(String name) {
      this.name = name;
     }
     public void update(Observable o, Object arg) {
      System.out.println("[" + name + "] GetMessage:\n [" + new String((byte[]) arg) + "]");
     }
    }
      

  2.   

    我的到了这样的结果:
    serialEvent[1]    [bob] GetMessage:
     [+00035231C+00035231C+00035231C+00035231C]
    [joe] GetMessage:
     [+00035231C+00035231C+00035231C+00035231C]数据是10位,是不是'+'代表起始位,'C'代表停止位,中间是数据位?
    这是一连串数据,我要怎么样才能得到一个有效数据呢~~~
      

  3.   

    为什么我按你们写的程序运行到  serialPort = (SerialPort) portId.open("SerialReader", timeout);就停止了也没报什么异常信息?