apache mina串口程序

mina串口需要依靠的包



前几个包可以mina官网下载，最后一个minamycom.jar是我自己把org.apache.mina.transport.serial下的所有class打成的jar（http://m134.mail.qq.com/cgi-bin/frame_html?sid=H-tEBtnqbtrjOH4z&r=6e9e4c331cf2c905cc15bf23d15f5a27 下载）

主要是解决串口读数据一次最多读32个字节的问题，解决后通过传递一个参数来解决串口直到把所有数据一次性全部读出

1） rxtx-2.1-7-bins-r2下的

把rxtxParallel.dll，rxtxSerial.dll拷贝到Java\jdk1.6.0_10\jre\bin

把RXTXcomm.jar拷贝到Java\jdk1.6.0_10\jre\lib\ext

环境变量中添加CLASSPATH=;C:\Program Files\Java\jdk1.6.0_10\jre\lib\ext\RXTXcomm.jar

2）下载了apache-mina-2.0.2-src.zip找到src下的mina-transport-serial把其中的org及其以下的目录放在myeclipse项目的src下

修改org.apache.mina.transport.serial包下的SerialSessionImpl.java如下

[java] view
plaincopy





/*

* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements. See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership. The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License. You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0
*

* Unless required by applicable law or agreed to in writing,

* software distributed under the License is distributed on an

* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

* KIND, either express or implied. See the License for the

* specific language governing permissions and limitations

* under the License.

*

*/

package org.apache.mina.transport.serial;

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.io.OutputStream;

import java.util.TooManyListenersException;

import org.apache.mina.core.buffer.IoBuffer;

import org.apache.mina.core.filterchain.DefaultIoFilterChain;

import org.apache.mina.core.filterchain.IoFilterChain;

import org.apache.mina.core.service.DefaultTransportMetadata;

import org.apache.mina.core.service.IoProcessor;

import org.apache.mina.core.service.IoServiceListenerSupport;

import org.apache.mina.core.service.TransportMetadata;

import org.apache.mina.core.session.AbstractIoSession;

import org.apache.mina.core.write.WriteRequest;

import org.apache.mina.util.ExceptionMonitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

* An imlpementation of SerialSession}.

*

* @author <a href="apache/'>http://mina.apache.org">Apache MINA Project</a>

*/

class SerialSessionImpl extends AbstractIoSession implements SerialSession, SerialPortEventListener {

static final TransportMetadata METADATA = new DefaultTransportMetadata("rxtx", "serial", false, true,

SerialAddress.class, SerialSessionConfig.class, IoBuffer.class);

private final IoProcessor<SerialSessionImpl> processor = new SerialIoProcessor();

private final IoFilterChain filterChain;

private final IoServiceListenerSupport serviceListeners;

private final SerialAddress address;

private final SerialPort port;

private final Logger log;

private InputStream inputStream;

private OutputStream outputStream;

SerialSessionImpl(SerialConnector service, IoServiceListenerSupport serviceListeners, SerialAddress address,

SerialPort port) {

super(service);

config = new DefaultSerialSessionConfig();

this.serviceListeners = serviceListeners;

filterChain = new DefaultIoFilterChain(this);

this.port = port;

this.address = address;

log = LoggerFactory.getLogger(SerialSessionImpl.class);

}

public SerialSessionConfig getConfig() {

return (SerialSessionConfig) config;

}

public IoFilterChain getFilterChain() {

return filterChain;

}

public TransportMetadata getTransportMetadata() {

return METADATA;

}

public SerialAddress getLocalAddress() {

return null; // not applicable

}

public SerialAddress getRemoteAddress() {

return address;

}

@Override

public SerialAddress getServiceAddress() {

return (SerialAddress) super.getServiceAddress();

}

public void setDTR(boolean dtr) {

port.setDTR(dtr);

}

public boolean isDTR() {

return port.isDTR();

}

public void setRTS(boolean rts) {

port.setRTS(rts);

}

public boolean isRTS() {

return port.isRTS();

}

/**

* start handling streams

*

* @throws IOException

* @throws TooManyListenersException

*/

void start() throws IOException, TooManyListenersException {

inputStream = port.getInputStream();

outputStream = port.getOutputStream();

ReadWorker w = new ReadWorker();

w.start();

port.addEventListener(this);

((SerialConnector) getService()).getIdleStatusChecker0().addSession(this);

try {

getService().getFilterChainBuilder().buildFilterChain(getFilterChain());

serviceListeners.fireSessionCreated(this);

} catch (Throwable e) {

getFilterChain().fireExceptionCaught(e);

processor.remove(this);

}

}

private final Object writeMonitor = new Object();

private WriteWorker writeWorker;

private class WriteWorker extends Thread {

@Override

public void run() {

while (isConnected() && !isClosing()) {

flushWrites();

// wait for more data

synchronized (writeMonitor) {

try {

writeMonitor.wait();

} catch (InterruptedException e) {

log.error("InterruptedException", e);

}

}

}

}

}

private void flushWrites() {

for (;;) {

WriteRequest req = getCurrentWriteRequest();

if (req == null) {

req = getWriteRequestQueue().poll(this);

if (req == null) {

break;

}

}

IoBuffer buf = (IoBuffer) req.getMessage();

if (buf.remaining() == 0) {

setCurrentWriteRequest(null);

buf.reset();

this.getFilterChain().fireMessageSent(req);

continue;

}

int writtenBytes = buf.remaining();

try {

outputStream.write(buf.array(), buf.position(), writtenBytes);

buf.position(buf.position() + writtenBytes);

// increase written bytes

increaseWrittenBytes(writtenBytes, System.currentTimeMillis());

setCurrentWriteRequest(null);

buf.reset();

// fire the message sent event

getFilterChain().fireMessageSent(req);

} catch (IOException e) {

this.getFilterChain().fireExceptionCaught(e);

}

}

}

private final Object readReadyMonitor = new Object();

int dataSize;

// long l1=0;

private class ReadWorker extends Thread {

@Override

public void run() {

while (isConnected() && !isClosing()) {

synchronized (readReadyMonitor) {

try {

readReadyMonitor.wait();

} catch (InterruptedException e) {

log.error("InterruptedException", e);

}

if (isClosing() || !isConnected()) {

break;

}

try {

/*if(l1==0){

l1=System.currentTimeMillis();

}else{

long l2=System.currentTimeMillis();

System.out.println(l2-l1);

l1=l2;

}*/

while(inputStream.available()>dataSize){

dataSize = inputStream.available();

Thread.sleep(address.getWaitMs());//参数一般是200毫秒，这个参数也可以自己输入我的电脑每次读数据的间隔是200毫秒左右

}

byte[] data = new byte[dataSize];

int readBytes = inputStream.read(data);

if (readBytes > 0) {

IoBuffer buf = IoBuffer.wrap(data, 0, readBytes);

buf.put(data, 0, readBytes);

buf.flip();

getFilterChain().fireMessageReceived(buf);

}

dataSize=0;

} catch (IOException e) {

getFilterChain().fireExceptionCaught(e);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

}

public void serialEvent(SerialPortEvent evt) {

if (evt.getEventType() == SerialPortEvent.DATA_AVAILABLE) {

synchronized (readReadyMonitor) {

readReadyMonitor.notifyAll();

}

}

}

@Override

public IoProcessor<SerialSessionImpl> getProcessor() {

return processor;

}

private class SerialIoProcessor implements IoProcessor<SerialSessionImpl> {

public void add(SerialSessionImpl session) {

// It's already added when the session is constructed.

}

public void flush(SerialSessionImpl session) {

if (writeWorker == null) {

writeWorker = new WriteWorker();

writeWorker.start();

} else {

synchronized (writeMonitor) {

writeMonitor.notifyAll();

}

}

}

public void remove(SerialSessionImpl session) {

try {

inputStream.close();

} catch (IOException e) {

ExceptionMonitor.getInstance().exceptionCaught(e);

}

try {

outputStream.close();

} catch (IOException e) {

ExceptionMonitor.getInstance().exceptionCaught(e);

}

try { // Turn flow control off right before close to avoid deadlock

port.setFlowControlMode(SerialPort.FLOWCONTROL_NONE);

} catch (UnsupportedCommOperationException e) {

ExceptionMonitor.getInstance().exceptionCaught(e);

}

port.close();

flush(session);

synchronized (readReadyMonitor) {

readReadyMonitor.notifyAll();

}

serviceListeners.fireSessionDestroyed(SerialSessionImpl.this);

}

public void updateTrafficControl(SerialSessionImpl session) {

throw new UnsupportedOperationException();

}

public void dispose() {

// Nothing to dispose

}

public boolean isDisposed() {

return false;

}

public boolean isDisposing() {

return false;

}

}

}

3）测试程序：

[java] view
plaincopy





package com;

import org.apache.mina.core.future.ConnectFuture;

import org.apache.mina.core.service.IoConnector;

import org.apache.mina.core.session.IoSession;

import org.apache.mina.core.session.IoSessionConfig;

import org.apache.mina.transport.serial.SerialAddress;

import org.apache.mina.transport.serial.SerialConnector;

import org.apache.mina.transport.serial.SerialAddress.DataBits;

import org.apache.mina.transport.serial.SerialAddress.FlowControl;

import org.apache.mina.transport.serial.SerialAddress.Parity;

import org.apache.mina.transport.serial.SerialAddress.StopBits;

public class Test {

public static void main(String[] args) {

SerialConnector connector = new SerialConnector();

connector.setHandler(new myComHandler());//DataBits dataBits, StopBits stopBits, Parity parity, FlowControl flowControl

SerialAddress portAddress=new SerialAddress( "COM5", 2400,DataBits.DATABITS_8, StopBits.BITS_1, Parity.EVEN, FlowControl.XONXOFF_IN,new Long(200));

ConnectFuture future = connector.connect(portAddress);

try {

future.await();

} catch (InterruptedException e) {

e.printStackTrace();

}

IoSession sessin = future.getSession();

// sessin.getFilterChain().addFirst("first", new addfilter());

IoSessionConfig sc=sessin.getService().getSessionConfig();

sessin.setAttribute("comname", "COM5");

String s="1111111111111111111111111111111111111111111111111111111111111111111111";

s=s.replace(" ", "");

System.out.println(s);

byte[]b=Convert.hexStringToBytes(s);

sessin.write(Convert.byteToIoBuffer(b, b.length));

connector.dispose();

}

}