java串口通信
javaCommunications API 简介 (1)
利用Java实现串口(Comm)全双工通(应广大读者要求,已做修改,附件有代码) (3)
主题：JA V A操作串口有感 (5)
windows中java实现的串口通信 (11)
Java串口通信-01 (18)
Java串口通信-2 (19)
笔记本电脑没有com端口 (28)
如何把com3接口改为com1接口?com1,com3在结构上和用途上有差别吗? (29)
javaCommunications API 简介
Java提供了CommunicationAPI(包含于https://www.wendangku.net/doc/401388919.html,包中)用于通过与机器无关的方式，控制各种外部设备。Communications API，是标准的Java的扩展部分，它在JavaAPI中是没有附带的。因此，必须先在SUN公司网站的Java站点(https://www.wendangku.net/doc/401388919.html,)上下载这个扩展类库。
1.1Communications API 简介
Communications API 的核心是抽象的CommPort类及其两个子类：SerialPort类和ParallePort类。其中，SerialPort类是用于串口通信的类，ParallePort类是用于并行口通信的类。CommPort类还提供了常规的通信模式和方法，例如:getInputStream( )方法和getOutputStream( )方法，专用于与端口上的设备进行通信。
然而，这些类的构造方法都被有意的设置为非公有的(non-public)。所以，不能直接构造对象，而是先通过静态的CommPortIdentifer.getPortIdentifiers()获得端口列表；再从这个端口列表中选择所需要的端口，并调用CommPortIdentifer对象的Open( )方法，这样，就能得到一个CommPort对象。当然，还要将这个CommPort对象的类型转换为某个非抽象的子类，表明是特定的通讯设备。该子类可以是SerialPort类和ParallePort类中的一个。下面将分别对CommPort类，CommPortIdentifier类，串口类SerialPort进行详细的介绍。
1.2 CommPortIdentifier类
CommPortIdentifier类的方法如下：
方法说明
addPortName(String, int, CommDriver) 添加端口名到端口列表里addPortOwnershipListener(CommPortOwnershipListener) 添加端口拥有的监听器removePortOwnershipListener(CommPortOwnershipListener) 移除端口拥有的监听器getCurrentOwner() 得到当前占有端口的对象或应用程序
getName() 得到端口名称getPortIdentifier(CommPort) 得到参数打开的端口的CommPortIdentifier 类型对象.
getPortIdentifier(String) 得到以参数命名的端口的CommPortIdentifier 类型对象
getPortIdentifiers() 得到系统中的端口列表
getPortType() 得到端口的类型
isCurrentlyOwned() 判断当前端口是否被占用
open(FileDescriptor) 用文件描述的类型打开端口
open(String, int) 打开端口,两个参数：程序名称,延迟时间(毫秒数)
1.3 SerialPort类
《1》SerialPort关于串口参数的静态成员变量：
成员变量说明成员变量说明成员变量说明
DA TABITS_5 数据位为5 ，STOPBITS_2 停止位为2 ，PARITY_ODD 奇检验
DA TABITS_6 数据位为6，STOPBITS_1 停止位为1，PARITY_MARK 标记检验DA TABITS_7 数据位为7，STOPBITS_1_5 停止为1.5，PARITY_NONE 空格检验
DA TABITS_8 数据位为8，PARITY_EVEN 偶检验，PARITY_SPACE 无检验
《2》SerialPort对象的关于串口参数的函数：
方法说明
getBaudRate() 得到波特率
getParity() 得到检验类型
getDataBits() 得到数据位数
getStopBits() 得到停止位数
setSerialPortParams(int, int, int, int) 设置串口参数依次为(波特率,数据位,停止位,奇偶检验)
《3》SerialPort关于事件的静态成员变量：
成员变量说明
BI Break interrupt中断
FE Framing error错误
CD Carrier detect载波侦听
OE Overrun error错误
CTS Clear to send清除以传送
PE Parity error奇偶检验错误
DSR Data set ready数据备妥
RI Ring indicator响铃侦测
DATA_A V AILABLE 串口中的可用数据
OUTPUT_BUFFER_EMPTY 输出缓冲区空
《4》SerialPort中关于事件的方法：
方法说明
isCD() 是否有载波
isCTS() 是否清除以传送
isDSR() 数据是否备妥
isDTR() 是否数据端备妥
isRI() 是否响铃侦测
isRTS() 是否要求传送
addEventListener(SerialPortEventListener) 向SerialPort对象中添加串口事件监听器
removeEventListener() 移除SerialPort对象中的串口事件监听器
notifyOnBreakInterrupt(boolean) 设置中断事件true有效,false无效
notifyOnCarrierDetect(boolean) 设置载波监听事件true有效,false无效
notifyOnCTS(boolean) 设置清除发送事件true有效,false无效
notifyOnDataAvailable(boolean) 设置串口有数据的事件true有效,false无效
notifyOnDSR(boolean) 设置数据备妥事件true有效,false无效
notifyOnFramingError(boolean) 设置发生错误事件true有效,false无效notifyOnOutputEmpty(boolean) 设置发送缓冲区为空事件true有效,false无效notifyOnParityError(boolean) 设置发生奇偶检验错误事件true有效,false无效notifyOnRingIndicator(boolean) 设置响铃侦测事件true有效,false无效
getEventType() 得到发生的事件类型返回值为int型
sendBreak(int) 设置中断过程的时间，参数为毫秒值
setRTS(boolean) 设置或清除RTS位
setDTR(boolean) 设置或清除DTR位
《5》SerialPort中的其他常用方法
方法说明
close() 关闭串口
getOutputStream() 得到OutputStream类型的输出流
getInputStream() 得到InputStream类型的输入流
利用Java实现串口(Comm)全双工通(应广大读者要求,已做修改,附件有代码)
本人因为项目开发的需要，需要PC机和硬件的通讯，而这个通讯通过Comm串口实现，而最好又是全双工的通讯，譬如一个流水线控制系统需要不断的接受从主控系统发送来的查询和控制信息，并将执行结果或查询结果发送回主控系统。本文介绍了一个简单的通过串口实现全双工通讯的Java类库，该类库大大的简化了对串口进行操作的过程。
本类库主要包括：SerialBean.java (与其他应用程序的接口), SerialBuffer.java (用来保存从串口所接收数据的缓冲区), ReadSerial.java (从串口读取数据的程序)。另外本类库还提供了一个例程SerialExample.java 作为示范。在下面的内容中将逐一对这几个部分进行详细介绍。
1. SerialBean
SerialBean是本类库与其他应用程序的接口。该类库中定义了SerialBean的构造方法以及初始化串口，从串口读取数据，往串口写入数据以及关闭串口的函数。具体介绍如下：public SerialBean(int PortID)
本函数构造一个指向特定串口的SerialBean，该串口由参数PortID所指定。PortID = 1 表示COM1，PortID = 2 表示COM2，由此类推。
public int Initialize()
本函数初始化所指定的串口并返回初始化结果。如果初始化成功返回1，否则返回-1。初始化的结果是该串口被SerialBean独占性使用，其参数被设置为9600, N, 8, 1。如果串口被成功初始化，则打开一个进程读取从串口传入的数据并将其保存在缓冲区中。
public String ReadPort(int Length)
本函数从串口(缓冲区)中读取指定长度的一个字符串。参数Length指定所返回字符串的长度。
public void WritePort(String Msg)
本函数向串口发送一个字符串。参数Msg是需要发送的字符串。
public void ClosePort()
本函数停止串口检测进程并关闭串口。
2. SerialBuffer
SerialBuffer是本类库中所定义的串口缓冲区，它定义了往该缓冲区中写入数据和从该缓冲区中读取数据所需要的函数。
public synchronized String GetMsg(int Length)
本函数从串口(缓冲区)中读取指定长度的一个字符串。参数Length指定所返回字符串的长度。
public synchronized void PutChar(int c)
本函数望串口缓冲区中写入一个字符，参数c 是需要写入的字符。
在往缓冲区写入数据或者是从缓冲区读取数据的时候，必须保证数据的同步，因此GetMsg 和PutChar函数均被声明为synchronized并在具体实现中采取措施实现的数据的同步。
3. ReadSerial
ReadSerial是一个进程，它不断的从指定的串口读取数据并将其存放到缓冲区中。
public ReadSerial(SerialBuffer SB, InputStream Port)
本函数构造一个ReadSerial进程，参数SB指定存放传入数据的缓冲区，参数Port指定从串口所接收的数据流。
public void run()
ReadSerial进程的主函数，它不断的从指定的串口读取数据并将其存放到缓冲区中。
4. SerialExample
SerialExample是本类库所提供的一个例程。它所实现的功能是打开串口COM1，对其进行初始化，从串口读取信息对其进行处理后将处理结果发送到串口。
5. 编译与调试
本类库中使用了Java Communication API (https://www.wendangku.net/doc/401388919.html,m)。这是一个Java扩展类库，并不包括在标准的Java SDK当中。如果你尚未安装这个扩展类库的话，你应该从Sun公司的Java站点下载这个类库并将其安装在你的系统上。在所下载的包里面包括一个安装说明，如果你没有正确安装这个类库及其运行环境的话，运行这个程序的时候你会找不到串口。
正确安装Java Communication API并将上述程序编译通过以后，你可以按如下方法测试这个程序。如果你只有一台机器，你可以利用一条RS-232电缆将COM1和COM2连接起来，在COM1上运行SerialExample，在COM2上运行Windows提供的超级终端程序。如果你有两台机器的话，你可以利用一条RS-232电缆将两台机器的COM1(或者是COM2)连接起来，在一端运行例程，另外一端运行Windows提供的超级终端程序。如果有必要的话，可以对SerialExample中所声明的串口进行相应改动。
本程序在Windows 2000 + Java SDK 1.3环境下编译通过并成功运行。
如想要这几个文件的原代码，请留言，而且也能帮忙调试，因为关键在环境部署上，不能出错。
应广大读者的需要，本人把代码简单做了整理,特意发出来让大家相互学习!
?serial.rar (5.6 KB)
?描述: 就此整理发出去，让大家互相学习!
?下载次数: 824
主题：JA V A操作串口有感
在做过一年多的RXTX操作串口项目有现在把一些平时遇到的问题在这里写写：
RXTX是一个开源包，主要是在COMM开源包中做扩张，以前的COMM包只能在WINDOWS下面对串口或并口做操作，扩充后的RXTX可以在LINUX和MAC下对串口和并口做操作。现在跨平台：
在RXTX网站下载JAR包和动态库
https://www.wendangku.net/doc/401388919.html,/jarvi/rxtx/download.html
下载后配置环境
Windows
拷贝RXTXcomm.jar 文件到\jre\lib\ext 目录下
拷贝rxtxSerial.dll文件到\jre\bin目录下
Mac OS X (x86 and ppc) (there is an Installer with the source)
MAC下面我自己没有配置环境成功，后来找一个MAC下RXTX的安装把环境配置好的。https://www.wendangku.net/doc/401388919.html,/how-to/mac-os-x/下载安装环境配置文件RXTX_Tiger.pkg
Linux (only x86, x86_64, ia64 here but more in the ToyBox)
拷贝RXTXcomm.jar 文件到/jre/lib/ext 目录下
拷贝librxtxSerial.so 文件到/jre/lib/[machine type] (i386 for instance)目录下
并将拷贝文件释放权限给所有用户
Solaris (sparc only so far)
拷贝RXTXcomm.jar 文件到/jre/lib/ext 目录下
拷贝librxtxSerial.so 文件到/jre/lib/[machine type]目录下
并将拷贝文件释放权限给所有用户
环境搭建好后开始写代码实现
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TooManyListenersException;
import https://www.wendangku.net/doc/401388919.html,mPortIdentifier;
import gnu.io.NoSuchPortException;
import gnu.io.PortInUseException;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
public class SerialComm implements SerialPortEventListener, Runnable {
public final static String PORT_OWER = "MonitorApp";
private boolean isOpen;
private boolean isStart;
private boolean isSave;
private boolean isPrint;
private Thread readThread;
private String portName;
private String portAddress;
private CommPortIdentifier portId;
private SerialPort serialPort;
private DataInputStream inputStream;
private OutputStream outputStream;
private SimpleDateFormat formatter;
// prase data with process
private String dataProtocol;
private Object readWriteLock = new Object();
public SerialComm() {
isOpen = false;
isStart = false;
isSave = true;
isPrint = false;
formatter = new SimpleDateFormat("[yyyy-MM-dd hh:mm:ss,SSS]");
portName = "COM1";
portAddress = "LOCAL";
dataProtocol = "Gooseli";
}
public void init(String port, String protocol) throws Exception
{
portName = port;
portAddress = portName;
dataProtocol = protocol;
init();
}
public void init(String port, String address, String protocol) throws Exception {
portName = port;
portAddress = address;
dataProtocol = protocol;
init();
}
public void init() throws IOException, Exception, Exception
{
if (isOpen)
{
close();
}
try
{
//传送串口名创建CommPortIdentifier对象服务。
portId = CommPortIdentifier.getPortIdentifier(portName);
//使用portId对象服务打开串口，并获得串口对象
serialPort = (SerialPort) portId.open(PORT_OWER, 2000);
//通过串口对象获得读串口流对象
inputStream = new DataInputStream(serialPort.getInputStream());
//通过串口对象获得写串口流对象
outputStream = serialPort.getOutputStream();
isOpen = true;
} catch (NoSuchPortException ex)
{
throw new Exception(ex.toString());
} catch (PortInUseException ex)
{
throw new Exception(ex.toString());
}
}
public void start() throws Exception
{
if (!isOpen)
{
throw new Exception(portName + " has not been opened.");
}
try
{
//创建对象线程
readThread = new Thread(this);
readThread.start();
//设置串口数据时间有效
serialPort.notifyOnDataAvailable(true);
//增加监听
serialPort.addEventListener(this);
isStart = true;
} catch (TooManyListenersException ex)
{
throw new Exception(ex.toString());
}
}
public void run()
{
String at = "at^hcmgr=1\r";
String strTemp = at + (char) Integer.parseInt("1a", 16) + "z";
writeComm(strTemp);
isPrint = true;
}
public void stop()
{
if (isStart)
{
serialPort.notifyOnDataAvailable(false);
serialPort.removeEventListener();
isStart = false;
}
}
public void close()
{
stop();
if (isOpen)
{
try
{
inputStream.close();
outputStream.close();
serialPort.close();
isOpen = false;
} catch (IOException ex)
{
}
}
}
//如果串口有数据上报则主动调用此方法
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_A V AILABLE:
readComm();
break;
default:
break;
}
}
public void readComm()
{
StringBuffer readBuffer = new StringBuffer();
String scannedInput = "";
Date currentTime = null;
String TimeStamp = "";
int c;
char a;
try
{
InputStreamReader fis = new InputStreamReader(inputStream, "utf-8");
while ((c = fis.read()) != -1)
{
readBuffer.append((char) c);
}
scannedInput = readBuffer.toString().trim();
currentTime = new Date();
TimeStamp = formatter.format(currentTime);
} catch (IOException ex)
{
ex.printStackTrace();
} catch (Exception ex)
ex.printStackTrace();
}
}
public void writeComm(String outString)
{
synchronized (readWriteLock)
{
try
{
outputStream.write(outString.getBytes());
} catch (IOException ex)
{
}
}
}
public static void main(String[] args)
{
SerialComm serialcomm = new SerialComm();
try
{
serialcomm.init("COM3", "Air");// windows下测试端口
// serialcomm.init("/dev/ttyUSB0", "Air");//linux下测试端口
serialcomm.start();
} catch (Exception ex)
{
}
}
}
windows中java实现的串口通信通过修改sample例程,使用observer模式实现串口通信数据的订阅读取.以下为俺的原创程序:
实现功能如下:
1. 在windows中监听指定的串口
2. observer模式订阅端口数据,可以有多个数据监听者同时接收数据
先到sun网站上下载串口通信库
https://www.wendangku.net/doc/401388919.html,/products/javacomm/index.jsp
再下载windows中的dll库
https://www.wendangku.net/doc/401388919.html,/
java实现源程序如下
------------------ 1 ---------------------
package serial;
import gnu.io.SerialPort;
import java.util.HashMap;
public class CommTest {
/**
* windows中串口通信程序需要rxtxSerial.dll的支持,放到D:\jdk1.5\bin目录下即可 */
public static void main(String[] args) {
HashMap
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 https://www.wendangku.net/doc/401388919.html,mPort;
import https://www.wendangku.net/doc/401388919.html,mPortIdentifier;
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的串口数据读取
*
*
* @author Macro Lu
* @version 2007-4-4
*/
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
HashSet
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) {
https://www.wendangku.net/doc/401388919.html, = name;
}
public void update(Observable o, Object arg) {
System.out.println("[" + name + "] GetMessage:\n [" + new String((byte[]) arg) + "]");
}
}
Java串口通信-01
找啊找，找到了comm3.0，结果发现没有Windows版。
再找comm2.0，有Windows版滴，不过是98年的老古董了，不过俺是实用主义者。。。
安装好后，运行测试程序，汗，A发A的，B根本收不到，为啥嗷！！？？
找。。。找。。。找。。。
难道是线不对？
两台PC用串口线互连，要交叉彼此的收信针和发信针。
嗯，有这可能，用网线互联的时候不就一个要a头，一个要b头滴么。
找找看。。。
Java串口通信-2
发现果然是串口线的问题啊。。。
哎，用两台pc来调试程序麻烦，用虚拟串口吧。
下载了VSPM，虚拟出4个串口。
COM3和COM4运行在server模式，COM5和COM6运行在client模式。嗯，用COM3和COM5来通信。
测试代码如下:
//SwitchBoard.java . 模拟了一个电话交换机，呵呵
package simulateCTI;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.TooManyListenersException;
import https://www.wendangku.net/doc/401388919.html,mPortIdentifier;
import https://www.wendangku.net/doc/401388919.html,m.PortInUseException;
import https://www.wendangku.net/doc/401388919.html,m.SerialPort;
import https://www.wendangku.net/doc/401388919.html,m.SerialPortEvent;
import https://www.wendangku.net/doc/401388919.html,m.SerialPortEventListener;
import https://www.wendangku.net/doc/401388919.html,m.UnsupportedCommOperationException;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JRadioButton;
public class SwitchBoard extends JFrame implements Runnable, ActionListener, SerialPortEventListener {
static final String PORT_TO_USE = "COM3";// virtual port for simulation.
char ACK = (byte) 0x06;
char STX = (byte) 0x02;
char ETX = (byte) 0x03;
String MSG1 = STX + "20070801HphoneNumIs0507289960" + ETX; boolean endKeepCallFlag = false;
static CommPortIdentifier PortId;// used to check the port.
static Enumeration portList;// list all the availble ports.
SerialPort serialPort;
OutputStream outputStream = null;
InputStream inputStream = null;
String Msg;
// GUI
JButton simulateOneCall = new JButton("Simulate One Call"); JRadioButton ACKed = new JRadioButton("Got ACK");
SwitchBoard() {
// Set GUI
super("Simulate the SwitchBoard. Will send Msg to Computer.");
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setSize(300, 300);
this.setVisible(true);
this.setLayout(new FlowLayout());
this.add(simulateOneCall);
this.add(ACKed);
this.pack();
simulateOneCall.addActionListener(this);
// Build serial port connection.
openSerialPort();
}
public void run() {
// TODO Auto-generated method stub
while (true) {
try {
Thread.sleep(500);
java串口编程,java串口通信,监听者模式解析
java调用coms端口串口通信的方法。 首先需要下到串口驱动。javacomm20-win32.zip 去sun的主页应该有下的。 在这个驱动中有comm.jar，https://www.wendangku.net/doc/401388919.html,m.properties，win32com.dll 这么3个重要的文件。 1、首先配置驱动，把https://www.wendangku.net/doc/401388919.html,m.properties，win32com.dll拷贝到你的jdk 中 具体位置为C:\Program Files\Java\jdk1.6.0_06\bin 然后配置windows系统环境变量，在path中加入C:\Program Files\Java\jdk1.6.0_06\bin; 打开你的java工程，配置user library,并导入comm.jar包。 2、现在就可以开始写代码了。串口读写代码如下 CommPortIdentifier portID = CommPortIdentifier.getPortIdentifier(com);//1，先拿到Identifier //其中com是String类型的，传入的是串口名com="COM1"; SerialPort port = (SerialPort)portID.open("MyComm", 100000000);//2,打开串口 //"MyComm"是串口名，100000000是串口过期时间（ms）。 port.setSerialPortParams(rate, databits,stopbit, parity);//3，设置串口属性 //rate 波特率（默认9600），databits载波位（默认8），stopbit停止位（默认1），parity校验位（默认0无校验） port.setFlowControlMode(SerialPort.FLOWCONTROL_NONE);//4（可选）设置数据流控制模式，默认为无 port.close();//关闭串口 3、串口读入写出流。
java串口通信程序(程序及注释)-13页word资料
Java的串口通信程序 首先需要到到sun主页下载串口通信的包，因为一般的jrd中不含有这个包的，有点补丁的意思。（CSDN上也有）。解压缩，为了使Java Communications API能够正确的与Windows系统交互，需要几个小的技巧。下面是三个很重要的文件，你可以从Sun的网站上下载得到 comm.jar win32com.dll javaxm.properties 对于JVM来说，要正确的识别串口，将这几个文件放在系统中合适的位置使很重要的。 comm..jar应该放在以下目录中 %JAVA_HOME%/lib %JAVA_HOME%/jre/lib/ext win32com.dll应该放在以下目录中 %windir%system32 javax.properties应该放在以下目录中 %JAVA_HOME%/lib
%JAVA_HOME%/jre/lib 你可以通过编译和运行Sun的例程来验证串口是否可以使用了。 JBuilder中安装安装Java Communication API （以下在JBuilder 2006中测试通过） 如果你使用JBuilder，那么还需要为JBuilder配置API。 一般来说，根据你的JBuilder配置，你也许需要将win32com.dll和javax.properties安装到相应的目录中，可以参照上述的目录。例如，如果你使用JBuilder附带的JVM的话，你也许需要将win32com.dll和javax.properties放到C:\Borland\JBuilder2006\jdk1.5的相应位置。 我使用的是JCreator，在打开Configure，然后点击option，选中jdk profile然后双击选中的jdk文件，选择edit，在弹出的窗口中选择串口通信包所在的文件（.jar文件），这样配置就算完成了。 以下分别是接收和发送程序，CSDN上搜的，省的自己写了：发送程序： import java.awt.*; import java.awt.event.*; import java.io.*; import java.util.*;
java串口通讯程序
java串口通讯程序 1、下载java Communications api开发包。| 是Sun公司提供的，用于开发平台独立的通讯应用程序的扩展API。 2、将拷贝入C:\j2sdk1.4.2_04\bin 3、将拷贝入C:\j2sdk1.4.2_04\jre\lib\ext 4、将拷贝入C:\j2sdk1.4.2_04\jre\lib 5、编译文件 import .*; import .*; import .*; public class CommTest{ public static void main(String[] args){ SerialPort serialPort=null; DataOutputStream doutput=null; InputStream inputStream; CommPortIdentifier portId=null; String messageString="hello \n"; try{ portId=("COM1"); }catch(NoSuchPortException ne) { "ne"); (); } try{ serialPort=(SerialPort) ("TestComm", 5); OutputStream output = (); doutput=new DataOutputStream(output); inputStream = (); }catch(PortInUseException ex) { "ex"); (); }catch(IOException ie) { "ie"); (); //(); } try { (9600, , , ; } catch (UnsupportedCommOperationException e) {} } try { ()); } catch (IOException e) {}
Java串口通信编程指南
Java串口通信编程指南
1. 概述 在java中，利用Java Communication包可以操作串口，但官方的包在3.0之后就只支持Linux和Solaris平台了，Windows平台的只支持到98年出的2.0版本，不过在XP下还能使用。另外，也可以用开源的Rxtx实现串口通信，这里仅以Java Communication包，在Windows 平台实现串口通信进行说明。 2. 前期准备 2.1. 下载Java Communication包 ?下载地址如下：https://www.wendangku.net/doc/401388919.html,/Jolt/javacomm20-win32.zip。 ?如果是非Windows平台，请到Sun网站选择其他版本下载。地址如下： https://www.wendangku.net/doc/401388919.html,/download/products.xml?id=43208d3d 2.2. 配置 ?解压缩javacomm20-win32.zip ?把win32com.dll拷贝到{JAVA_HOME}\jre\bin ?把comm.jar拷贝到{JAVA_HOME}\jre\lib\ext ?把https://www.wendangku.net/doc/401388919.html,m.properties拷贝到{JAVA_HOME}\jre\lib ?set CLASSPATH={JAVA_HOME}\jre \lib\ext \comm.jar;%classpath%
3. 实现过程 主要步骤包括： ?获得串口标识 ?打开串口 ?设置串行端口通讯参数 ?获取输入（出）流 ?进行读写操作 3.1. 获得串口标识 指定串口的端口号，生成串口的标识类的实例。 https://www.wendangku.net/doc/401388919.html,mPortIdentifier是通讯端口管理器，控制访问到通讯端口的中心类。一个应用程序首先使用CommPortIdentifier中的方法，通过相关的驱动去获取那些通讯端口是可用的并且选择一个端口便于开始。它包括如下功能： a. 通过驱动决定通讯端口是可用的。 b. 打开通讯端口为了I/O操作。 c. 决定端口的拥有者。 d. 解析端口拥有者的争夺。 e. 管理事件显示在端口拥有者的中的状态改变。 示例代码如下： 代码: 3.2. 打开串口 示例代码如下： 代码:
Java串口通信详解
Java串口通信详解 序言 说到开源，恐怕很少有人不挑大指称赞。学生通过开源代码学到了知识，程序员通过开源类库获得了别人的成功经验及能够按时完成手头的工程，商家通过开源软件赚到了钱……，总之是皆大欢喜。然而开源软件或类库的首要缺点就是大多缺乏详细的说明文档和使用的例子，或者就是软件代码随便你用，就是文档，例子和后期服务收钱。这也难怪，毕竟就像某个著名NBA 球员说的那样：“我还要养家，所以千万美元以下的合同别找我谈，否则我宁可待业”。是啊，支持开源的人也要养家，收点钱也不过分。要想既不花钱又学到知识就只能借助网络和了，我只是想抛砖引玉，为开源事业做出点微薄共献，能为你的工程解决哪怕一个小问题，也就足够了。 虽然我的这个系列介绍的东西不是什么Web框架，也不是什么开源服务器，但是我相信，作为一个程序员，什么样的问题都会遇到。有时候越是简单的问题反而越棘手；越是小的地方就越是找不到称手的家伙。只要你不是整天只与“架构”、“构件”、“框架”打交道的话，相信我所说的东西你一定会用到。 1串口通信简介 1.1常见的Java串口包 1.2串口包的安装（Windows下） 2串口API概览 https://www.wendangku.net/doc/401388919.html,mPort https://www.wendangku.net/doc/401388919.html,mPortIdentifier https://www.wendangku.net/doc/401388919.html,m.SerialPort 2.4串口API实例 2.4.1列举出本机所有可用串口 2.4.2串口参数的配置 2.4.3串口的读写 3串口通信的通用模式及其问题 3.1事件监听模型 3.2串口读数据的线程模型 3.3第三种方法 4结束语 1串口通信简介 嵌入式系统或传感器网络的很多应用和测试都需要通过PC机与嵌入式设备或传感器节点进行通信。其中，最常用的接口就是RS-232串口和并口（鉴于USB接口的复杂性以及不需要很大的数据传输量，USB接口用在这里还是显得过于奢侈，况且目前除了SUN有一个支持USB 的包之外，我还没有看到其他直接支持USB的Java类库）。SUN的CommAPI分别提供了对常用的RS232串行端口和IEEE1284并行端口通讯的支持。RS-232-C(又称EIA RS-232-C，以下简称RS232)是在1970年由美国电子工业协会(EIA)联合贝尔系统、调制解调器厂家及计算机终端生产厂家共同制定的用于串行通讯的标准。RS232是一个全双工的通讯协议，它可以同时进行数据接收和发送的工作。 1.1 常见的Java串口包 目前，常见的Java串口包有SUN在1998年发布的串口通信API：comm2.0.jar（Windows 下）、comm3.0.jar（Linux/Solaris）；IBM的串口通信API以及一个开源的实现。鉴于在Windows下SUN的API比较常用以及IBM的实现和SUN的在API层面都是一样的，那个开源的实现又不像两家大厂的产品那样让人放心，这里就只介绍SUN的串口通信API在Windows 平台下的使用。 1.2 串口包的安装（Windows下） 到SUN的网站下载javacomm20-win32.zip，包含的东西如下所示：
Java串口通信编程指导
Java串口通信编程指导 Java串口通信编程
概述 在java中，利用Java Communication包能够操作串口，但官方的包在3.0之后就只支持Linux和Solaris平台了，Windows平台的只支持到98年出的2.0版本，只是在XP下还能使用。另外，也能够用开源的Rxtx实现串口通信，那个地点仅以Java Communication包，在Windows平台实现串口通信进行讲明。 前期预备 下载Java Communication包 下载地址如下：https://www.wendangku.net/doc/401388919.html,/Jolt/javacomm20-win32.zip。 配置 解压缩javacomm20-win32.zip 把win32com.dll拷贝到{JA V A_HOME}\jre\bin 把comm.jar拷贝到{JA V A_HOME}\jre\lib\ext set CLASSPATH={JA V A_HOME}\jre \lib\ext \comm.jar;%classpath%
实现过程 要紧步骤包括： 获得串口标识 打开串口 设置串行端口通讯参数 猎取输入（出）流 进行读写操作 获得串口标识 指定串口的端口号，生成串口的标识类的实例。 a. 通过驱动决定通讯端口是可用的。 b. 打开通讯端口为了I/O操作。 c. 决定端口的拥有者。 d. 解析端口拥有者的争夺。 e. 治理事件显示在端口拥有者的中的状态改变。示例代码如下： 代码: 打开串口 示例代码如下： 代码:
5000（毫秒）是超时时刻。 设置串行端口通讯参数 设置串口传输的波特率、数据位、停止位、奇偶校验等参数。 示例代码如下： 代码: try { // 通信条件の設定 // 通信速度 9600 baud // データビット 8bit // ストップビット 1bit // パリティなし // フローコントロールの設定 // 無制御を使用 port.setSerialPortParams(9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); port.setFlowControlMode(SerialPort.FLOWCONTROL_NONE); } catch (UnsupportedCommOperationException ex) { ex.printStackTrace(); System.exit(1); } 猎取输入（出）流 利用getInputStream()以及getOutputStream()从每个串口产生对应的输入输出流对象。 示例代码如下： 代码:
一个通过JAVA串口通信控制LED显示数据的实例
一个通过java串口通信控制LED显示数据的实例 在很多应用程序中都需要用到pc机与外部设备如：嵌入式系统、传感器、开关 设备等进行数据通讯。其中，最常用的接口就是RS-232串口和并口。SUN的 CommAPI分别提供了对常用的RS232串行端口和IEEE1284并行端口通讯的支持。 至于java串口通讯的配置以及通讯模式在sun的demo以及网上都有很多具体的 实例。 下面是我在开发一个叫号功能模块时通过串口通信来控制LED显示的实例，由于 第一次进行相关的开发，看似一个非常简单的功能在实际开发中却遇到了一些问 题，希望本人的解决方式能够对大家有所帮助，也希望大家能够提出更好的解决 方式。 先看一下LED显示屏厂商提供的通讯协议： ---遥控单双色、单双行、混合屏 一、每一次对任一特定地址发送信息由内码帧(7f/7e)，数码帧 (6f/6e)，定时帧(5f)，时间帧(4f)中的一种或多种构成，结束 时发送一结束帧。 二、帧结构：每帧由84字节构成。 1、内码帧：一幕由一起始帧和零或多个中间帧组成，一次 发送可有多幕。 1）起始帧：地址（1字节）＋帧控制7F（1字节） ＋幕号（1字节）+COMMAND（8字节） +内码/ASCII（73字节） 2）中间帧：地址（1字节）＋帧控制7E（1字节）＋ 幕号（1字节）+COMMAND（8字节）+内码/ASCII （73字节） 3）COMMAND： 前4字节未定义，后4字节依次为动画（0～4），移入及移出（各16种），速度（0～255），追加 （D3连续、D2停止、D0闪烁、D4时间、D6暂停、 D7动画） 4）内码/ASCII结构： a、内码4字节，依次为控制字节（D7宽体/正常体、D4绿色、D5红色、D3粗体、D2细体反白、D1 粗体反白、D0细体），内码高位，内码低位，未用 b、ASCII2字节，依次为控制字节（D7宽体/正常体、D5绿色、D4红色、D3粗体、D2细体反白、D1粗体 反白、D0细体），ASCII码 2、数码帧：由一起始帧和零或多中间帧组成。 1）起始帧：地址（1字节）＋帧控制6F（1字节）＋ 数据（82字节）
Java 串口通讯 RS232
通过comm.jar等配置 如果用applet应用程序的话，下面这个函数是可以取到串口的，但是如果通过web应用程序（或者通过jsp调用）却取不到串口，而且也不会抛出异常，感觉很奇怪，特来请教！ CommPortIdentifier.getPortIdentifiers(); 同时目标机器的java运行环境也需要把w32comm.dll, comm.jar xxx.proper等放到相应的目录 就是用ibm的包而不用sun的comm包： ibm-javacomm-win32-x86.zip 只需要把comm驱动包这个类的装载更新一下即 https://www.wendangku.net/doc/401388919.html,/serialcomm.htm 利用Java实现串口全双工通讯 一个嵌入式系统通常需要通过串口与其主控系统进行全双工通讯，譬如一个流水线控制系统需要不断的接受从主控系统发送来的查询和控制信息，并将执行结果或查询结果发送回主控系统。本文介绍了一个简单的通过串口实现全双工通讯的Java类库，该类库大大的简化了对串口进行操作的过程。 本类库主要包括：SerialBean.java (与其他应用程序的接口), SerialBuffer.java(用来保存从串口所接收数据的缓冲区), ReadSerial.java (从串口读取数据的程序)。另外本类库还提供了一个例程SerialExample.java 作为示范。在下面的内容中将逐一对这几个部分进行详细介绍。 1. SerialBean SerialBean是本类库与其他应用程序的接口。该类库中定义了SerialBean的构造方法以及初始化串口，从串口读取数据，往串口写入数据以及关闭串口的函数。具体介绍如下： 本函数构造一个指向特定串口的SerialBean，该串口由参数PortID所指定。PortID = 1 表示COM1，PortID = 2 表示COM2，由此类推。 本函数初始化所指定的串口并返回初始化结果。如果初始化成功返回1，否则返回-1。初始化的结果是该串口被SerialBean独占性使用，其参数被设置为9600, N, 8, 1。如果串口被成功初始化，则打开一个进程读取从串口传入的数据并将其保存在缓冲区中。
java串口通信
小技巧：如何辨别TXD和RXD端口？ 搞电子的人手边应该常备一个电表，用来测测电压，电阻什么的会很有用。你只要分别测一下RS232端口的2--5或3--5针脚之间的电压，通常TXD针脚与GND之间会有 3~15V左右的负电压，表示它是TXD针脚。 安装JavaCommunicationsAPI Sun的J2SE中并没有直接提供以上提到的任何一种串行通讯协议的开发包，而是以独立的jar包形式发布在https://www.wendangku.net/doc/401388919.html,网站上(从这里下载)----即comm.jar，称之为Javatm CommunicationsAPI，它是J2SE的标准扩展。comm.jar并不是最近才有，早在1998年时，sun就已经发布了这个开发包。comm.jar分别提供了对常用的RS232串行端口和IEEE1284并行端口通讯的支持。目前sun发布的comm.jar只有Windows和Solaris平台两个版本，如果你需要Linux平台下的，可以在 https://www.wendangku.net/doc/401388919.html,/~kevinh/linuxcomm.html找到。 在使用comm.jar之前，必须知道如何安装它。这也是困扰许多初学javaRS232通讯者的一个难题。如果我们电脑上安装了JDK,它将同时为我们安装一份JRE(Java RuntimeEntironment)，通常我们运行程序时都是以JRE来运行的。所以以下的安装适用于JRE。如果你是用JDK来运行程序的，请将相应的改成。 下载了comm.jar开发包后，与之一起的还有两个重要的文件，win32com.dll和https://www.wendangku.net/doc/401388919.html,m.properties。comm.jar提供了通讯用的javaAPI，而win32com.dll提供了供comm.jar调用的本地驱动接口。而https://www.wendangku.net/doc/401388919.html,m.properties是这个驱动的类配置文件。首先将comm.jar复制到\lib\ext目录。再将win21com.dll复制到你的RS232应用程序运行的目录，即user.dir。然后将https://www.wendangku.net/doc/401388919.html,m.properties复制到\lib目录。 通讯前的准备 如果你手头上没有现成的提供了标准RS232串口的设备，你可以将自己的电脑模拟成两台不同的串口设备。通常电脑主机后面的面板提供了两个9针的串口，请将这两个串口的2,3,5脚按前面介绍的方法连接。电子市场都有现成的连接头卖，请不要买那种封装的严严实实的接头，而要买用螺丝封装可以拆开的连接头，这样可以方便自己根据需要连接各 个针脚。 Comm API基础 我无意于在此详细描述Comm API每个类和接口的用法，但我会介绍CommAPI的 类结构和几个重要的API用法。 所有的comm API位于https://www.wendangku.net/doc/401388919.html,m包下面。从CommAPI的javadoc来看，它 介绍给我们的只有区区以下13个类或接口： https://www.wendangku.net/doc/401388919.html,mDriver https://www.wendangku.net/doc/401388919.html,mPort https://www.wendangku.net/doc/401388919.html,m.ParallelPort
java串口通信
java串口通信API说明 java串口通信 Java提供了 CommunicationAPI(包含于https://www.wendangku.net/doc/401388919.html,m包中)用于通过与机器无关的方式，控制各种外部设备。Communications API，是标准的Java的扩展部分，它在JavaAPI中是没有附带的。因此，必须先在SUN公司网站的Java站点(https://www.wendangku.net/doc/401388919.html,)上下载这个扩展类库。 1.1Communications API 简介 Communications API 的核心是抽象的CommPort类及其两个子类：SerialPort类和ParallePort类。其中，SerialPort类是用于串口通信的类，ParallePort类是用于并行口通信的类。CommPort类还提供了常规的通信模式和方法，例如:getInputStream( )方法和getOutputStream( )方法，专用于与端口上的设备进行通信。 然而，这些类的构造方法都被有意的设置为非公有的(non-public)。所以，不能直接构造对象，而是先通过静态的CommPortIdentifer.getPortIdentifiers()获得端口列表；再从这个端口列表中选择所需要的端口，并调用CommPortIdentifer对象的Open( )方法，这样，就能得到一个CommPort对象。当然，还要将这个CommPort对象的类型转换为某个非抽象的子类，表明是特定的通讯设备。该子类可以是SerialPort类和ParallePort类中的一个。下面将分别对CommPort类，CommPortIdentifier类，串口类SerialPort进行详细的介绍。
Java实现串口通信
这是用Java编写的实现串口通信的程序源代码。至于支持串口通信的comm.jar 包，请各位从sun或别的网站处下载！这里只提供源码让大家参考。 gui.java算是一个框架；panel.java是面板，相当于前台；SerialCommunication.java是一个JavaBean，相当于后台。面板视图如下： 从串口中读入信息的机制如下：后台监测到有信息读入到缓存，就读取之，用一个字符串变量储存，并置“有新信息读入”的标识（相当于一个开关）为真。面板有一个计时器监听器，用轮询的方式查询后台的“有新信息读入”的标识是否为真，若为真则马上读入到前台，显示到文本框上，并置“有新信息读入”的标识为假（顺手关门）。 gui.java: import java.awt.*; import javax.swing.*; public class gui { public static void main(String[] args) { JFrame frame=new JFrame("密谈"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.getContentPane().add(new panel()); frame.pack(); frame.setVisible(true);
frame.setResizable(false); } } panel.java： import java.awt.*; import java.awt.event.*; import javax.swing.*; public class panel extends JPanel { String SB; JTextArea show; JTextField text; JButton submit,connect,stop; SerialCommunication port; Timer timer; JPanel write; JPanel read; public panel() { SB=new String(""); port=new SerialCommunication(1); timer=new Timer(100,new timeListener()); show=new JTextArea(20,25); show.setLineWrap(true); show.setAutoscrolls(true); text=new JTextField("",25); submit=new JButton("提交"); connect=new JButton("连接"); stop=new JButton("断开"); write=new JPanel(); read=new JPanel(); setLayout(new BoxLayout(this,BoxLayout.Y_AXIS)); submit.addActionListener(new submitListener()); connect.addActionListener(new connectListener()); stop.addActionListener(new stopListener()); write.setPreferredSize(new Dimension(300,70)); write.add(text); write.add(connect); write.add(submit); write.add(stop); write.setBackground(Color.CYAN);
java 串口通讯实例
java 串口通讯实例（转） 2010-01-28 12:33 java串口通讯 最近在搞C的串口通讯，C里面没有线程的概念，所以C对串口的读写只能在一个进程里面，这样 如果串口的缓存有问题，就会导致报告丢失（正好是我们遇到的），我们来看看支持线程的java是如何来解决这个问题的。 本文介绍了一个简单的通过串口实现全双工通讯的Java类库，该类库大大的简化了对串口进行操作的过程。 本类库主要包括：SerialBean.java (与其他应用程序的接口), SerialBuffer.java (用来保存从串口所接收数据的缓冲区), ReadSerial.java (从串口读取数据的程序)。另外本类库还提供了一个例程SerialExample.java 作为示范。在下面的内容中将逐一对这几个部分进行详细介绍。 SerialBean SerialBean是本类库与其他应用程序的接口。该类库中定义了SerialBean的构造方法以及初始化串口，从串口读取数据，往串口写入数据以及关闭串口的函数。具体介绍如下： public SerialBean(int PortID) 本函数构造一个指向特定串口的SerialBean，该串口由参数PortID所指定。PortID = 1 表示COM1，PortID = 2 表示COM2，由此类推。 public int Initialize() 本函数初始化所指定的串口并返回初始化结果。如果初始化成功返回1，否则返回-1。初始化的结果是该串口被SerialBean独占性使用，其参数被设置为9600, N, 8, 1。如果串口被成功初始化，则打开一个进程读取从串口传入的数据并将其保存在缓冲区中。 public String ReadPort(int Length) 本函数从串口(缓冲区)中读取指定长度的一个字符串。参数Length指定所返回字符串的长度。 public void WritePort(String Msg) 本函数向串口发送一个字符串。参数Msg是需要发送的字符串。 public void ClosePort() 本函数停止串口检测进程并关闭串口。 SerialBean的源代码如下： package serial; import java.io.*; import java.util.*; import https://www.wendangku.net/doc/401388919.html,m.*; /** *
java串口api介绍
java串口API java串口API Java提供了CommunicationAPI(包含于https://www.wendangku.net/doc/401388919.html,m包中)用于通过与机器无关的方式，控制各种外部设备。Communications API，是标准的Java的扩展部分，它在JavaAPI中是没有附带的。因此，必须先在SUN公司网站的Java站点(https://www.wendangku.net/doc/401388919.html,)上下载这个扩展类库。 1.1Communications API简介 Communications API的核心是抽象的CommPort类及其两个子类：SerialPort类和ParallePort类。其中，SerialPort类是用于串口通信的类，ParallePort类是用于并行口通信的类。CommPort类还提供了常规的通信模式和方法，例如:getInputStream()方法和getOutputStream()方法，专用于与端口上的设备进行通信。 然而，这些类的构造方法都被有意的设置为非公有的(non-public)。所以，不能直接构造对象，而是先通过静态的CommPortIdentifer.getPortIdentifiers()获得端口列表；再从这个端口列表中选择所需要的端口，并调用CommPortIdentifer对象的Open()方法，这样，就能得到一个CommPort对象。当然，还要将这个CommPort对象的类型转换为某个非抽象的子类，表明是特定的通讯设备。该子类可以是SerialPort类和ParallePort类中的一个。下面将分别对CommPort类，CommPortIdentifier类，串口类SerialPort进行详细的介绍。 1.2CommPortIdentifier类 CommPortIdentifier类的方法如下： 方法说明 addPortName(String,int,CommDriver)添加端口名到端口列表里addPortOwnershipListener(CommPortOwnershipListener)添加端口拥有的监听器removePortOwnershipListener(CommPortOwnershipListener)移除端口拥有的监听器getCurrentOwner()得到当前占有端口的对象或应用程序 getName()得到端口名称 getPortIdentifier(CommPort)得到参数打开的端口的CommPortIdentifier类型对象getPortIdentifier(String)得到以参数命名的端口的CommPortIdentifier类型对象getPortIdentifiers()得到系统中的端口列表 getPortType()得到端口的类型 isCurrentlyOwned()判断当前端口是否被占用 open(FileDescriptor)用文件描述的类型打开端口 open(String,int)打开端口,两个参数：程序名称,延迟时间(毫秒数) 1.3SerialPort类 SerialPort关于串口参数的静态成员变量 成员变量说明成员变量说明成员变量说明 DATABITS_5数据位为5STOPBITS_2停止位为2PARITY_ODD奇检验
Java串口通信编程教程_hao
Win32 串口编程（一）(2009-08-16 16:28:13) 标签：串口重叠i/o 分类：Windows 翻译自：ms-help://MS.MSDNQTR.v80.chs/MS.MSDN.v80/MS.WIN32COM.v10.en/dnfiles/html/msdn_s erial.htm 老外写的文章，虽比较全面，但很啰嗦，不如看各个函数的文档来得快。为方便以后查阅，列出本文涉及的主要函数如下： CreateFile、ReadFile、WriteFile、GetOverlappedResult、WaitForSingleObject SetCommMask、WaitCommEvent ClearCommError、GetCommModemStatus、EscapeCommFunction GetCommState、BuildCommDCB、SetCommState、SetCommTimeouts 此外，新浪的博客系统限制文章最大长度为40000字节，只好把这篇文章分成几部分了。 0 简介 本文仅关注在Windows NT和95间兼容的API。Windows 95支持Telephony API(TAPI)，但Windows NT 3.x不支持TAPI，所以本文不讨论它。 本文的示例程序MTTTY(Multithreaded TTY)使用了三个线程：一个进行内存管理的界面线程；控制所有写入操作的写入者线程；读取数据和处理端口状态改变的读取/状态线程。示例采用了一些不同的堆来进行内存管理；还大量使用了同步方法来进行线程间通信。 1 打开端口 使用CreateFile函数打开端口。打开端口时有两种方法：重叠的和非重叠的。下列代码片段以重叠方式打开端口： HANDLE hComm; hComm = CreateFile( gszPort, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0); if (hComm == INV ALID_HANDLE_V ALUE) // error opening port; abort Win32 串口编程（二）(2009-08-16 16:39:32) 标签：串口重叠i/o it 分类：Windows 3 串口状态 有两种获取通信端口状态的方法。第一种方法是设置事件掩码，当指定事件发生时应用程序会收到通知。SetCommMask函数用于设置事件掩码，WaitCommEvent用于等待指定的事件发生。它们与16位Windows中的SetCommEventMask和EnableCommNotification类似，只是它们不发送WM_COMMNOTIFY消息。第二种方法是不时地调用另一些状态函数来获取通信端口的状态。当然，轮询是低效的，不建议使用。 3.1 通信事件 通信事件在使用通信端口时可能随时发生。接收通信事件需要两个步骤： 用SetCommMask设定需要接收通知的事件
java串口通讯程序
java 串口通讯程序 1、下载java Communications api 开发包。| https://www.wendangku.net/doc/401388919.html,m是Sun公司提供的，用于开发平台独立的通讯应用程序的扩展 API 。 2、将win32com.dll 拷贝入C:\j2sdk1.4.2_04\bin 3、将comm.jar 拷贝入C:\j2sdk1.4.2_04\jre\lib\ext 4、将https://www.wendangku.net/doc/401388919.html,m.properties 拷贝入C:\j2sdk1.4.2_04\jre\lib 5、编译CommTest.java 文件 import java.io.*; import java.util.*; import https://www.wendangku.net/doc/401388919.html,m.*; public class CommTest{ public static void main(String[] args){ SerialPort serialPort=null; DataOutputStream doutput=null; InputStream inputStream; CommPortIdentifier portId=null; String messageString="hello \n"; try{ portId=CommPortIdentifier.getPortIdentifier("COM1"); }catch(NoSuchPortException ne) { System.out.println("ne"); ne.printStackTrace(); } try{ serialPort=(SerialPort) portId.open("TestComm", 5); OutputStream output = serialPort.getOutputStream(); doutput=new DataOutputStream(output); inputStream = serialPort.getInputStream(); }catch(PortInUseException ex) { System.out.println("ex"); ex.printStackTrace(); }catch(IOException ie) { System.out.println("ie"); ie.printStackTrace(); //serialPort.close(); } try { serialPort.setSerialPortParams(9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); } catch (UnsupportedCommOperationException e) {} } try { doutput.write(messageString.getBytes()); } catch (lOException e) {} } 6、串口打开后，用InputStream和DataOutputStream读写就可以了。 7、由于串口为共享资源，所以在设计程序时应采用单例模式。 8、A PI 在https://www.wendangku.net/doc/401388919.html,m下有13个类和接口，分别是
java串口通信代码
利用java实现串口全双工通讯 (投稿) qingye jiang (john) smth id: qyjohn e-mail : qjiang@https://www.wendangku.net/doc/401388919.html, 一个嵌入式系统通常需要通过串口与其主控系统进行全双工通讯，譬如一个流水线控制系统需要不断的接受从主控系统发送来的查询和控制信息，并将执行结果或查询结果发送回主控系统。本文介绍了一个简单的通过串口实现全双工通讯的java类库，该类库大大的简化了对串口进行操作的过程。 本类库主要包括：serialbean.java (与其他应用程序的接口), serialbuffer.java (用来保存从串口所接收数据的缓冲区), readserial.java (从串口读取数据的程序)。另外本类库还提供了一个例程serialexample.java 作为示范。在下面的内容中将逐一对这几个部分进行详细介绍。 1. serialbean serialbean是本类库与其他应用程序的接口。该类库中定义了serialbean的构造方法以及初始化串口，从串口读取数据，往串口写入数据以及关闭串口的函数。具体介绍如下： public serialbean(int portid) 本函数构造一个指向特定串口的serialbean，该串口由参数portid所指定。 portid = 1 表示com1，portid = 2 表示com2，由此类推。 public int initialize() 本函数初始化所指定的串口并返回初始化结果。如果初始化成功返回1，否 则返回-1。初始化的结果是该串口被serialbean独占性使用，其参数被设置 为9600, n, 8, 1。如果串口被成功初始化，则打开一个进程读取从串口传 入的数据并将其保存在缓冲区中。 public string readport(int length) 本函数从串口(缓冲区)中读取指定长度的一个字符串。参数length指定所返 回字符串的长度。 public void writeport(string msg) 本函数向串口发送一个字符串。参数msg是需要发送的字符串。 public void closeport() 本函数停止串口检测进程并关闭串口。
Java串口通信
Java串口通信 1.Java串口通信实现 在Java中，利用Java Communication API可以操作计算机的串口，Jar包的名称为comm.jar，但是这个包只合适于Windows平台的操作系统，其它的操作系统需要其它的Jar包。Comm.jar包由Sun公司发布，分别提供了对常用的RS232串行端口和IEEE1284并行端口通信的支持。Java Communication API和环境变量配置所需要的文件我已经打包后放在同文档的目录下，名称为：javacomm20-win32.zip。 1.1.通信前的准备工作 在实现与计算机串口通信之前，需要对Java作一些相应的环境变量配置，配置步骤很简单，只需三步即可完成。 win32com.dll拷贝到{JAVA_HOME}\jre\bin 把comm.jar拷贝到{JAVA_HOME}\jre\lib 把https://www.wendangku.net/doc/401388919.html,m.properties拷贝到{JA V A_HOME}\jre\lib 说明：为什么这些文件都是放到jre路径下呢？这是因为通常运行“Java MyApp” 的时候，都是由JRE下的虚拟机启动的。只有放在“这里”，虚拟机才能顺利的找到相应的文件，不然可能会提示找不到串口的错误信息。 1.2.Java Communication API的大概认识 这里没有详细描述CommAPI每个类和接口的用法，只介绍案例代码中有用到的主要类和接口的用法，这也是CommAPI最基础的类结构。下面截图是CommAPI的所有类：
https://www.wendangku.net/doc/401388919.html,mPort 这是用于描述被底层系统支持的端口的抽象类，通常常用的端口有串口和并口，该抽象类包含了IO的控制方法，这些方法对于所有不同的通信端口来说都是通用的。 SerialPort和ParallelPort是它的两个子类，分别表示串口和并口。两都对于各自底层的物理端口有着不同的控制方法。这里暂时只关注SerialPort类。 https://www.wendangku.net/doc/401388919.html,mPortIdentifier 这个类主要用于对串口进行管理和设置，是对串口进行访问控制的核心类。常用的方法有： ◆确定是否有可用的通信端口 ◆为IO操作打开通信端口 ◆决定端口的所有权 ◆处理端口所有权的争用 ◆管理端口通信引发的事件(Event) https://www.wendangku.net/doc/401388919.html,m.SerialPort 这个类描述了RS-232串口通信端口的底层类，它定义了串口通信所需要的基本功能。例如，通过它，用户可以直接对串口进行读、写及参数设置的工作。一个SerialPort 对象对应着一个端口。 1.3.串口通信的实现过程 串口通信的主要步骤包括： ◆获得串口标识 ◆打开串口 ◆设置串行端口通讯参数 ◆获取输入（出）流 ◆进行读写操作