자바 를 사용 하여 간단 한 직렬 통신 을 실현 하 다

11156 단어 Java주둥이커 뮤 니 케 이 션
본 박문 참고 자https://www.jb51.net/article/100269.htm
www.jb51.net/article/100269.htm
많은 사람들 이 이것 을 필요 로 할 줄 은 몰 랐 습 니 다.이 글 이 여러분 에 게 도움 이 될 수 있어 서 기 쁩 니 다.주요 도구 류 블 로그 에 이미 있 습 니 다.물론 작은 도구 소스 코드 의 메 일 박스 를 원 하면 됩 니 다.2019.09.05
최근 직렬 포트 와 읽 기와 쓰 기 를 접 했 습 니 다.자바 가 직렬 읽 기와 쓰 기 를 하 는 과정 을 기록 합 니 다.
1.자바 직렬 통신 을 지원 하 는 jar 패키지 가 져 오기:
Maven 프로젝트 의 pom.xml 에 RXTXcomm 의 의존 도 를 추가 하거나 RXTXcomm.jar 를 다운로드 하여 프로젝트 에 가 져 옵 니 다.
자바 직렬 통신 을 지원 하 는 jar 패 키 지 는 자바.com 이 오래 되 었 고 64 비트 시스템 은 지원 되 지 않 습 니 다.Rxtx 라 는 jar 패 키 지 를 사용 하 는 것 을 추천 합 니 다(32 비트/64 비트 모두 지원).
다운로드 주소:
http://xiazai.jb51.net/201612/yuanma/javamfzrxtx(jb51.net).rar(32 위)
http://xiazai.jb51.net/201612/yuanma/javamfzrxtx(jb51.net).rar(64 위)
메모:실행 중 자바.lang.Unsatisfied LinkError 오류 나 gnu.io 의 클래스 를 찾 을 수 없습니다.rxtx 압축 해제 패키지 의 rxtx Parallel.dll,rxtx Serial.dll 두 파일 을 C:\Windows\System 32 디 렉 터 리 에 복사 하면 이 오 류 를 해결 할 수 있 습 니 다.
2.코드 조작 직렬 포트 작성:
직렬 포트 에 필요 한 매개 변수 클래스:직렬 포트 를 연결 하 는 데 필요 한 매개 변 수 를 포함 하여 직렬 포트 를 호출 할 때 직렬 파 라 메 터 를 설정 하고 전달 하 는 데 편리 합 니 다.

/**
 *          
 * @author: LinWenLi
 * @date: 2018 7 21    4:30:40
 */
public class ParamConfig {

 private String serialNumber;//    
 private int baudRate; //    
 private int checkoutBit; //    
 private int dataBit; //    
 private int stopBit; //    
 
 public ParamConfig() {}
 
 /**
 *     
 * @param serialNumber    
 * @param baudRate    
 * @param checkoutBit    
 * @param dataBit    
 * @param stopBit    
 */
 public ParamConfig(String serialNumber, int baudRate, int checkoutBit, int dataBit, int stopBit) {
 this.serialNumber = serialNumber;
 this.baudRate = baudRate;
 this.checkoutBit = checkoutBit;
 this.dataBit = dataBit;
 this.stopBit = stopBit;
 }
 getter()...
 setter()...
}
직렬 작업 클래스:(그 안에 포 함 된 CustomException 은 사용자 정의 이상 클래스 로 이상 원인 을 던 지 는 데 만 사 용 됩 니 다.)

import gnu.io.CommPortIdentifier;
import gnu.io.PortInUseException;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import gnu.io.UnsupportedCommOperationException;

/**
 *                                ：      ，   ，  /     ，    ，        。
 */
//  ：          SerialPortEventListener
public class SerialPortUtils implements SerialPortEventListener {
 //              
 private CommPortIdentifier commPortId;
 //     
 private Enumeration<CommPortIdentifier> portList;
 // RS232  
 private SerialPort serialPort;
 //    
 private InputStream inputStream;
 //    
 private OutputStream outputStream;
 //         
 private String data;
 //             
 private String dataHex;/**
 *      
 * @author LinWenLi
 * @date 2018 7 21   3:44:16
 * @Description: TODO
 * @param: paramConfig              （         ） 
 * @return: void 
 * @throws
 */
 @SuppressWarnings("unchecked")
 public void init(ParamConfig paramConfig) {
 //             
 portList = CommPortIdentifier.getPortIdentifiers();
 //           
 boolean isExsist = false;
 //       
 while (portList.hasMoreElements()) {
  commPortId = portList.nextElement();
  //        
  if (commPortId.getPortType() == CommPortIdentifier.PORT_SERIAL) {
  //              
  if (paramConfig.getSerialNumber().equals(commPortId.getName())) {
   //     
   isExsist = true;
   //     
   try {
   // open:（     【    】，         ）
   serialPort = (SerialPort) commPortId.open(Object.class.getSimpleName(), 2000);
   //       
   serialPort.addEventListener(this);
   //           (   )
   serialPort.notifyOnDataAvailable(true);
   //         :   ，   ，   ,    
   serialPort.setSerialPortParams(paramConfig.getBaudRate(), paramConfig.getDataBit(),
    paramConfig.getStopBit(), paramConfig.getCheckoutBit());
   } catch (PortInUseException e) {
   throw new CustomException("     ");
   } catch (TooManyListenersException e) {
   throw new CustomException("     ");
   } catch (UnsupportedCommOperationException e) {
   throw new CustomException("    COMM      ");
   }
   //     
   break;
  }
  }
 }
 //             
 if (!isExsist) {
  throw new CustomException("      ！");
 }
 }

 /**
 *     SerialPortEventListener                
 */
 @Override
 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: //      
  //          
  readComm();
  break;
 default:
  break;
 }
 }

 /**
 *         
 * @author LinWenLi
 * @date 2018 7 21   3:43:04
 * @return: void 
 */
 public void readComm() {
 try {
  inputStream = serialPort.getInputStream();
  //         available          
  byte[] readBuffer = new byte[inputStream.available()];
  //          
  int len = 0;
  while ((len = inputStream.read(readBuffer)) != -1) {　　　　　　　　　//         
  data = new String(readBuffer, 0, len).trim();　　　　　　　　　//         
  dataHex = bytesToHexString(readBuffer);
  System.out.println("data:" + data);
  System.out.println("dataHex:" + dataHex);//         
  inputStream.close();
  inputStream = null;
  break;
  }
 } catch (IOException e) {
  throw new CustomException("         IO  ");
 }
 }

 /**
 *        
 * @author LinWenLi
 * @date 2018 7 21   3:45:22
 * @param: data 
 * @return: void 
 * @throws
 */
 public void sendComm(String data) {
 byte[] writerBuffer = null;
 try {
  writerBuffer = hexToByteArray(data);
 } catch (NumberFormatException e) {
  throw new CustomException("      ！");
 }
 try {
  outputStream = serialPort.getOutputStream();
  outputStream.write(writerBuffer);
  outputStream.flush();
 } catch (NullPointerException e) {
  throw new CustomException("     。");
 } catch (IOException e) {
  throw new CustomException("          IO  ");
 }
 }

 /**
 *     
 * @author LinWenLi
 * @date 2018 7 21   3:45:43
 * @Description:     
 * @param: 
 * @return: void 
 * @throws
 */
 public void closeSerialPort() {
 if (serialPort != null) {
  serialPort.notifyOnDataAvailable(false);
  serialPort.removeEventListener();
  if (inputStream != null) {
  try {
   inputStream.close();
   inputStream = null;
  } catch (IOException e) {
   throw new CustomException("        IO  ");
  }
  }
  if (outputStream != null) {
  try {
   outputStream.close();
   outputStream = null;
  } catch (IOException e) {
   throw new CustomException("        IO  ");
  }
  }
  serialPort.close();
  serialPort = null;
 }
 }

 /**
 *            
 */
 public String getDataHex() {
 String result = dataHex;
 //       
 dataHex = null;
 //       
 return result;
 }

 /**
 *        
 */
 public String getData() {
 String result = data;
 //       
 data = null;
 //       
 return result;
 }

 /**
 * Hex    byte
 * @param inHex     Hex   
 * @return     byte
 */
 public static byte hexToByte(String inHex) {
 return (byte) Integer.parseInt(inHex, 16);
 }

 /**
 * hex    byte  
 * @param inHex     Hex   
 * @return     byte    
 */
 public static byte[] hexToByteArray(String inHex) {
 int hexlen = inHex.length();
 byte[] result;
 if (hexlen % 2 == 1) {
  //   
  hexlen++;
  result = new byte[(hexlen / 2)];
  inHex = "0" + inHex;
 } else {
  //   
  result = new byte[(hexlen / 2)];
 }
 int j = 0;
 for (int i = 0; i < hexlen; i += 2) {
  result[j] = hexToByte(inHex.substring(i, i + 2));
  j++;
 }
 return result;
 }

 /**
 *             
 * @param byte[]
 * @return HexString
 */
 public static final String bytesToHexString(byte[] bArray) {
 StringBuffer sb = new StringBuffer(bArray.length);
 String sTemp;
 for (int i = 0; i < bArray.length; i++) {
  sTemp = Integer.toHexString(0xFF & bArray[i]);
  if (sTemp.length() < 2)
  sb.append(0);
  sb.append(sTemp.toUpperCase());
 }
 return sb.toString();
 }
}
직렬 작업 클래스 의 코드 호출:

public static void main(String[] args) {
  //           
  SerialPortUtils serialPort = new SerialPortUtils();
  //               ，     ，   ，   ，   ，   
  ParamConfig paramConfig = new ParamConfig("COM4", 9600, 0, 8, 1);
  //      ,    ，          
  serialPort.init(paramConfig);
  //         sendComm         
  serialPort.sendComm("FEF10A000000000000000AFF");
  //     
  serialPort.closeSerialPort();
 }
main 방법의 코드 를 실행 하고 직렬 포트 를 닫 지 않 을 때 프로그램 은 계속 열 려 있 고 자동 으로 감청 되 며 직렬 포트 에서 온 데 이 터 를 읽 습 니 다.
메모:하나의 직렬 포트 는 한 번 만 열 수 있 고 프로그램 호출 만 지원 합 니 다.
위 에 기 록 된 것 은 자바 가 직렬 데 이 터 를 성공 적 으로 조작 할 수 있 는 지 를 간단하게 테스트 하 는 것 입 니 다.본인 이 쓴 웹 엔 드 의 카드 판독 기 디 버 깅 기능 은 직렬 조작 류 를 바탕 으로 웹 인터페이스 를 작성 하고 요청 을 통 해 직렬 포트 의 오픈 닫 기와 해당 하 는 설정 을 제어 하 는 것 입 니 다.기능 이 비교적 간단 합 니 다.인터페이스 에 기록 하 십시오.


자바 로 간단 한 직렬 통신 을 실현 하 는 것 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.더 많은 자바 가 간단 한 직렬 통신 을 실현 하 는 내용 은 우리 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 조회 하 시기 바 랍 니 다.앞으로 많은 응원 바 랍 니 다!
C 언어 마 탑 게임 의 실현 코드
C 언어 수업 설계 의 계산기 기능

좋은 웹페이지 즐겨찾기

개발자 우수 사이트 수집

개발자가 알아야 할 필수 사이트 100선 추천 우리는 당신을 위해 100개의 자주 사용하는 개발자 학습 사이트를 정리했습니다
best100-homepage