原文地址：java 串口通信实现流程

--------------------------------------------------------------------------------

1、下载64位rxtx for java 链接：http://fizzed.com/oss/rxtx-for-java

2、下载下来的包解压后按照说明放到JAVA_HOME即JAVA的安装路径下面去

3、在maven的pom.xml下添加

    <dependency>
　　　　<groupId>org.rxtx</groupId>
　　　　<artifactId>rxtx</artifactId>
　　　　<version>2.1.7</version>
　　</dependency>

4、串口API

　　CommPort：端口的抽象类

　　CommPortIdentifier：对串口访问和控制的核心类

　　SerialPort：通过它可以直接对串口进行读、写及设置工作

5、列出本机可用端口

Enumeration<CommPortIdentifier> em = CommPortIdentifier.getPortIdentifiers();
　　while (em.hasMoreElements()) {
　　　　String name = em.nextElement().getName();
　　　　System.out.println(name);
　　}

6、一般步骤：打开串口得到串口对象==》设置参数==》对串口进行读写==》关闭串口，其中对串口进行读操作比较常用

//打开串口
　　CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier("COM4");//COM4是串口名字
　　CommPort commPort = portIdentifier.open("COM4", 2000);    //2000是打开超时时间
　　serialPort = (SerialPort) commPort;
　　//设置参数（包括波特率，输入/输出流控制，数据位数，停止位和齐偶校验）
　　serialPort.setSerialPortParams(9600,
　　SerialPort.DATABITS_8, SerialPort.STOPBITS_1,
　　SerialPort.PARITY_NONE);
　　//监听串口事件
　　serialPort.addEventListener(new Abc()); //Abc是实现SerialPortEventListener接口的类，具体读操作在里面进行
　　// 设置当有数据到达时唤醒监听接收线程
　　serialPort.notifyOnDataAvailable(true);
　　// 设置当通信中断时唤醒中断线程
　　serialPort.notifyOnBreakInterrupt(true);
　　//    in.close(); //关闭串口

Abc类内容，即读串口的具体操作：

public class Abc implements SerialPortEventListener {
    public void serialEvent(SerialPortEvent arg0) {
        // TODO Auto-generated method stub
        //对以下内容进行判断并操作
        /*
        BI -通讯中断
    　　CD -载波检测
    　　CTS -清除发送
    　　DATA_AVAILABLE -有数据到达
    　　DSR -数据设备准备好
    　　FE -帧错误
    　　OE -溢位错误
    　　OUTPUT_BUFFER_EMPTY -输出缓冲区已清空
    　　PE -奇偶校验错
        RI -　振铃指示
        */
        //switch多个，if单个
        if (arg0.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
            try {
                InputStream in = null;
                byte[] bytes = null;
                in = App.serialPort.getInputStream();

                int bufflenth = in.available();
                while (bufflenth != 0) {
                    // 初始化byte数组为buffer中数据的长度
                    bytes = new byte[bufflenth];
                    in.read(bytes);
                    System.out.println(new String(bytes));
                    bufflenth = in.available();
                }
                
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }    
}

写操作：

OutputStream out = serialPort.getOutputStream();
out.write(data); //byte[] data;
out.flush();

7、打开关闭串口等动作要有触发，异常要处理。—wxws

前

串口通信的基础知识，请参考博客：https://blog.csdn.net/xiaobaixiongxiong/article/details/83998436

串口通信就是计算机和外设之间，通过数据信号线、底线、控制线等，按位进行传输数据的一种通讯方式。这种通讯方式使用的数据线少。

串口是一种接口标准，它规定了接口的电气标准，没有规定接口插件电缆及使用的协议。

 

Python实现简单的串口通信

1 获取可用的串口列表：

参考代码：

 

import serial 

import serial.tools.list_ports

port_list = list(serial.tools.list_ports.comports())
print(port_list)

if len(port_list) == 0:
    print("无可用串口！")
else:
    for i in range(0, len(port_list)):
        print(port_list[i])



输出结果：


 

2 简单的串口通信

1. 从串口读数据

import serial # pyserial

try:
        # 端口：CNU； Linux上的/dev /ttyUSB0等； windows上的COM3等
        portx = "COM3"
        
        # 波特率，标准值有：50,75,110,134,150,200,300,600,1200,1800,2400,4800,9600,19200,38400,57600,115200
        bps = 115200

        # 超时设置，None：永远等待操作；
        #         0：立即返回请求结果；
        #        其他：等待超时时间（单位为秒）
        timex = None

        # 打开串口，并得到串口对象
        ser = serial.Serial(portx, bps, timeout=timex)
        print("串口详情参数：", ser)

        # # 十六进制的发送
        # result = ser.write(chr(0x06).encode("utf-8")) # 写数据
        # print("写总字节数：", result)

        # 十六进制的读取
        print(ser.read().hex()) # 读一个字节

        print("----------")
        ser.close() # 关闭串口

except Exception as e:
        print("error!", e)

2.从串口写

import serial # pyserial

try:
        # 端口：CNU； Linux上的/dev /ttyUSB0等； windows上的COM3等
        portx = "COM4"
        
        # 波特率，标准值有：50,75,110,134,150,200,300,600,1200,1800,2400,4800,9600,19200,38400,57600,115200
        bps = 115200

        # 超时设置，None：永远等待操作；
        #         0：立即返回请求结果；
        #        其他：等待超时时间（单位为秒）
        timex = 5

        # 打开串口，并得到串口对象
        ser = serial.Serial(portx, bps, timeout=timex)

        # 写数据
        result = ser.write("HELLO WORLD".encode("gbk"))
        print("写总字节数：", result)

        ser.close() # 关闭串口

except Exception as e:
        print("error!", e)

运行结果：（虽然写端写了11个字节，可是读端只读了一个(采用了16进制的方式显示））


 

3 借助串口通信实现的简单聊天器：

参考代码：

import serial
import threading

DATA = "" # 读取的数据
NOEND = True # 是否读取结束

# 读数据的本体
def read_data(ser):
    global DATA, NOEND

    # 循环接收数据（此为死循环，可用线程实现）
    while NOEND:
        if ser.in_waiting:
            DATA = ser.read(ser.in_waiting).decode("gbk")
            print("\n>> receive: ", DATA, "\n>>", end="")
            # print(">>", end="")
            if(DATA == "quit"):
                print("oppo seri has closen.\n>>", end="")
            


# 打开串口
def open_seri(portx, bps, timeout):
    ret = False
    try:
        # 打开串口，并得到串口对象
        ser = serial.Serial(portx, bps, timeout=timeout)

        # 判断是否成功打开
        if(ser.is_open):
            ret = True
            th = threading.Thread(target=read_data, args=(ser,)) # 创建一个子线程去等待读数据
            th.start()
    except Exception as e:
        print("error!", e)

    return ser, ret



# 关闭串口
def close_seri(ser):
    global NOEND
    NOEND = False
    ser.close()

# 写数据
def write_to_seri(ser, text):
    res = ser.write(text.encode("gbk")) # 写
    return res

# 读数据
def read_from_seri():
    global DATA
    data = DATA
    DATA = "" #清空当次读取
    return data

if __name__ == "__main__":
    
    # ser, ret = open_seri("COM4", 115200, None) # 串口com3、bps为115200，等待时间为永久
    # if ret == True: # 判断串口是否成功打开
    #     count = write_to_seri(ser, "exit")
    #     print("写入总字节数：", count)

    # 打开一个串口
    port = input("输入串口名：")
    ser, ret = open_seri(port, 115200, None) # 串口com3、bps为115200，等待时间为永久

    # oprate_lst = {"quit":close_seri}
    # print("操作数字所对应的行为，1:read_from_seri 2:write_to_seri 3:close_seri: ")
    while True:
        text = input(">>")
        write_to_seri(ser, text)
        if text == "quit":
            close_seri(ser)
            print("bye!")
            break
        

结果展示：


 

参考博客：


	
https://blog.csdn.net/xiaobaixiongxiong/article/details/83998436
	
	

	
https://www.cnblogs.com/dongxiaodong/p/9992083.html
	

通过esp8266与arduino通过串口通信实现数据传输，通过控制led的熄灭。实现物联网的基础。

使用的材料

arduion
	
esp8266 nodemcu
	
面包板
	
led灯、电阻、杜邦线
连接的示意图

 

两个硬件之间的连接通信为：

esp8266上的tx、rx通过杜邦线连接arduino 上的引脚6、7 。arudion上的8号引脚为输出引脚控制led的灯

程序源码：

esp8266程序代码

  模拟重互联网上获取到json数据。通过引脚的方式发送给arduino。使用ArduinoJosn的库生成json数据

一定是Serial.print的方式发送数据。要不然发送会失败，arduino是不会接收到数据的

/**
 * 实现esp8266发送数据给arduion实现led灯的闪亮
 */
#include <ArduinoJson.h>
#include <ESP8266WiFi.h> //ESP8266 Library
const char* ssid = "nova"; //Enter your Wi-Fi SSID
const char* password = "wifi.danke.life"; //Enter you Wi-Fi Password
int i=0;
void setup() {
    Serial.begin(9600);
    WiFi.begin(ssid, password); //connect to the network specified above
}

void loop() {
  if(i==0){
     Serial.print(sendJson("0"));//发送数据给arduino
    i=1;
    }else{
     Serial.print(sendJson("1"));//发送数据给arduino
    i=0;
  }
  delay(2000);
}

String sendJson(String data){
const size_t capacity = JSON_OBJECT_SIZE(1)+10;
DynamicJsonDocument doc(capacity);
doc["7"] = data;
String josn;
serializeJson(doc, josn);
return  josn;
  }

arduino程序源码

实现的主要功能：

接收esp8266的json数据
	
解析json数据
	
通过状态数据8号引脚，实现led灯的控制
/**
 * 接收esp8266发送的json数据，控制led灯
 */
#include <ArduinoJson.h>
#include <SoftwareSerial.h>
SoftwareSerial ESP_Serial(6, 7); //Tx,Rx
void setup() {
  Serial.begin(9600);
  ESP_Serial.begin(9600);
  delay(2000);
 Serial.println("Hello ESP8266.");// "初始化输出信息 hello world"
 //将8号引脚设置为输出模式
 pinMode(8,OUTPUT);//设置数字IO引脚为输出模式
}

void loop() {
String jsonData= json();
      if(jsonData.length()>0){
          const size_t capacity = JSON_OBJECT_SIZE(1) + 10;
       DynamicJsonDocument doc(capacity);
       deserializeJson(doc, jsonData);
       const char* root_7 = doc["7"]; // "0"
       int numKey=doc["7"].as<int>();
       Serial.print(numKey);
       digitalWrite(8,numKey);
       delay(300);
        }else{
          //不做操作
           delay(1000);        
   }
   
    
    
}
//获取sep8266上发送过来的数据
String json(){
  String comdata = "";
   while(ESP_Serial.available() > 0){//串口接收到数据
        comdata += char(ESP_Serial.read());//获取串口接收到的数据
          delay(2);
    }
    Serial.print(comdata);
  return comdata;
  }

SoftwareSerial使用该库获取ESP8266串口数据，使用ArduinoJson库解析json数据。

应用笔记
									
V1.0 2015/03/26
PC和FPGA间的串口通信实现

 
概述

 
本文将介绍PC和FPGA间的串口通信实现的基本思路和Verilog代码，对于通信而言，收发双方都要有相应的控制。PC端采用MATLAB控制串口进行操作。本文档将详细介绍这一过程。

		
修订历史
以下表格展示了本文档的修订过程
日期
版本号
修订内容
2015/03/26
V1.0
初始版本，运行正确

 
简介

 
PC端程序基于MATLAB 2014a 编写，本文档中提到的"MATLAB"均指该特定版本MATLAB。
							
    为何要做一套PC和FPGA之间通信的程序？之前的文档，包括《程序说明：MATLAB串口操作和GUI编程》和《应用笔记：采用FPGA实现UART转SPI》说明可以通过PC来"控制"FPGA进行相应的操作。在LDPC译码误码率仿真过程中，我们希望通过FPGA强大的计算能力来辅助计算，这时我们希望要能够完成PC传送数据，FPGA处理后发送回PC机的过程。本文档将介绍通过串口完成这一功能的整个过程。
当然，更广泛的来说，数据的处理过程，就应该包括数据的输入和输出。也就是说，对于FPGA来说，很多情况下必须要考虑将外界的数据接收、缓存、处理、缓存、输出的整个过程。这里数据的来源不仅仅能是PC，数据的格式或协议不仅仅能是串行通信协议。也就是说，本文档所介绍的是这一过程的一个特例。
本文档关注FPGA端的处理，对PC端处理不做详细说明。FPGA端处理包括
数据的接收
不同速率数据匹配
数据处理
数据的发送
其中数据接收和发送采用串行通信协议，帧格式如图 1。

 

							
图 1 串行数据帧格式
PC端通过MATLAB操作串口，仅仅只需要采取如下命令即可
    s=serial('COM1');
    fopen(s);
    fwrite(s,100); %写一个字节
								
    fread(s,[1  1],'unit8'); %读一个字节
								
    fclose(s);
    delete(s);

		
程序结构

 
程序结构如图 2所示

							
图 2 程序结构示意图

 
顶层文件仅仅只需要如下几个端口
input clk;            //时钟
								
input rxd;            //串口输入
								
input rst;            //复位，高有效
								
output rxt;            //串口输出
								
    即输入输出数据即可。后文将详细介绍各个模块的功能。

							
图 3 数据读取、缓存
    
 
serialRead的输入时钟是16倍的波特率（时钟不同源），输出的是8bit的并行数据，同时有输出有效的表示。此时输出的时钟也是16倍的波特率。
然而往往数据的处理模块的时钟是不同的。对于隔离时钟域来说，FIFO是一个很好的选择，但是这里由于考虑到译码需要接收到所有的数据之后才能够开始，而且数据在整个译码过程中需要保持，所以选择了双口RAM来匹配不同速率的数据。当然还有一个原因是我不太记得FIFO这个核则么用了。
inputram的clka是16倍的波特率，通过输入地址控制，每次接收到out_rdy有效后地址增1将data_in保存到RAM内部。Inputram的clkb是数据处理模块的时钟，通过相应的规则控制ram的addrb，控制data_out和data_out_enable信号，得到满足数据处理要求的数据流。

							
图 4 数据处理模块

 
    数据处理模块接收数据后处理输出data_out和data_out_enable

 

							
图 5 数据缓存输出

 
数据处理模块通过接收并存储data_out后，在满足一定条件下发送dout和dout_enable信号。其中clka为数据处理模块时钟频率，而clkb是1/16的波特率的频率。
serialWrite模块通过接收信号，在输出使能情况下，输出rxt。

		
信号说明

 
表格 1 confirm_top模块信号说明
信号
类型
功能
clk
input
时钟
rst
input
复位信号，高有效
rxd
input
串行信号输入
rst
output
串行信号输出
clk_count
reg[12:0]
计数分频
serial_out
wire[7:0]
串行数据并行输出（8bit）
serial_out_rdy
wire
输出数据有效
inputram_data_out
wire[7:0]
输入存储器输出
inputram_data_out_enable
wire
输入存储器输出有效
dataProcess_out
wire
数据处理输出
dataProcess_out_enable
wire
数据处理输出有效
outputram_out
wire[7:0]
输出存储器输出
outputram_out_enable
wire
输出存储器输出有效

 
表格 2 serialRead模块信号说明
信号
类型
功能
clk16x
input
16倍串口通信波特率的采样时钟
rst
input
复位信号，高有效
rxd
input
串口输入信号
serial_out
wire[7:0]
串行数据并行输出（8bit）
serial_out_rdy
wire
输出数据有效
clk1x_enable
reg
串口接收数据时钟使能
clk1x
wire
串口数据的采样时钟 

 
剩余模块比较简单，不做说明，我也懒得写了……

 

		
参考

							 
代码

 
注：以下代码介绍2560个PC的8bit的帧，之后处理取后1024帧的最高数据为，分为128帧传送回PC端。MATLAB代码略。

							
转载于:https://www.cnblogs.com/sea-wind2/p/4369264.html