硬件与软件是如何进行连接的
目录
一、硬件与软件连接的基础认知
在信息技术领域，硬件与软件犹如计算机系统的左右臂膀，相辅相成。硬件，是我们能够实实在在看到、触摸到的物理设备，像计算机的主机、显示器、键盘，以及各类传感器、控制器等 ，它们构成了整个信息处理系统的物理基础。而软件则是一系列按特定顺序组织的计算机数据和指令集合，以程序和文档的形式存在，通过在硬件上运行来发挥作用，比如我们日常使用的操作系统 Windows、办公软件 Microsoft Office，以及各类应用程序等。
硬件为软件提供了运行的物质载体，如果没有硬件，软件便如无本之木，无法执行任何指令。反之，软件赋予了硬件 “灵魂”，没有软件的调度与控制，硬件只是一堆毫无生机的冰冷设备。两者紧密相连，缺一不可，只有将它们有机地连接起来，才能构建出一个功能完备、高效运行的系统。
二、常见硬件设备与软件连接场景
（一）智能家居系统
在智能家居的世界里，软件与硬件的连接创造出了无数便捷、舒适的生活场景。想象一下，忙碌了一天的你，在下班回家的路上，通过手机上的智能家居控制软件，提前打开家中的空调，调节到适宜的温度；同时，让智能电饭煲开始煮饭 。当你踏入家门，灯光自动亮起，温馨的氛围瞬间笼罩。这一切的实现，都依赖于软件与硬件之间的紧密连接。
从技术原理上讲，智能家居设备通常配备有无线通信模块，如 Wi-Fi、蓝牙、ZigBee 等，通过这些模块，设备能够接入家庭网络。以智能灯泡为例，当你在手机应用程序中点击 “开灯” 按钮时，手机软件会将这一指令通过网络发送到家中的智能网关 。智能网关就像是一个 “翻译官”，它接收到指令后，将其转换成智能灯泡能够理解的信号，通过无线通信方式发送给智能灯泡，灯泡接收到信号后，便执行开灯的操作。
在 Java 代码实现方面，以基于 Spring Boot 框架开发智能家居控制后端为例，首先定义一个设备实体类，如SmartBulb：
public class SmartBulb {
private String id;
private String name;
private boolean isOn;
// 省略getter和setter方法
}接着创建一个服务类SmartBulbService，用于处理与智能灯泡相关的业务逻辑，例如控制灯泡开关：
import org.springframework.stereotype.Service;
@Service
public class SmartBulbService {
private SmartBulb smartBulb = new SmartBulb();
public void turnOn() {
smartBulb.setOn(true);
// 这里可以添加实际与硬件通信的逻辑，例如通过网络发送指令
System.out.println("灯泡已打开");
}
public void turnOff() {
smartBulb.setOn(false);
// 这里可以添加实际与硬件通信的逻辑，例如通过网络发送指令
System.out.println("灯泡已关闭");
}
}在控制器类SmartBulbController中，接收来自前端的请求，并调用服务类的方法：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/smartBulb")
public class SmartBulbController {
@Autowired
private SmartBulbService smartBulbService;
@PostMapping("/turnOn")
public String turnOn() {
smartBulbService.turnOn();
return "灯泡打开成功";
}
@PostMapping("/turnOff")
public String turnOff() {
smartBulbService.turnOff();
return "灯泡关闭成功";
}
}这样，通过前端界面发送请求到后端控制器，再由后端控制器调用服务类的方法，即可实现对智能灯泡的软件控制。
（二）工业自动化控制
在工业生产领域，软件与硬件的连接是实现高效、精准生产的关键。工厂中的各类机械设备，如自动化生产线、工业机器人、传感器等，都需要通过软件进行实时监测与精确操控。以汽车制造工厂为例，自动化生产线在生产过程中，每一个环节都需要精确控制。从零部件的组装到整车的喷漆，每一个动作都由软件发送指令给相应的硬件设备执行。
在这个场景中，软件与硬件之间的连接通常采用工业以太网、现场总线（如 PROFIBUS、CAN 总线等）等通信方式。以工业机器人的控制为例，工程师通过编写专门的控制软件，根据生产需求为机器人规划运动轨迹、动作顺序等。软件将这些指令通过网络发送给机器人的控制器，控制器再驱动机器人的各个关节电机，使机器人按照预定的动作执行任务。
在 Java 中，利用一些工业通信库可以实现与硬件设备的通信。例如，使用 JSerialComm 库来与串口设备进行通信。首先在pom.xml文件中添加依赖：
<dependency>
<groupId>com.fazecast</groupId>
<artifactId>jSerialComm</artifactId>
<version>2.8.0</version>
</dependency>然后编写代码实现向串口设备发送数据：
import com.fazecast.jSerialComm.SerialPort;
public class IndustrialControl {
public static void main(String[] args) {
SerialPort serialPort = SerialPort.getCommPort("COM1");// 根据实际端口修改
if (serialPort.openPort()) {
String dataToSend = "control_command";// 控制指令
byte[] data = dataToSend.getBytes();
int bytesWritten = serialPort.writeBytes(data, data.length);
if (bytesWritten == data.length) {
System.out.println("数据发送成功");
} else {
System.out.println("数据发送失败");
}
serialPort.closePort();
} else {
System.out.println("无法打开串口");
}
}
}这段代码实现了通过串口向硬件设备发送控制指令，在实际工业应用中，会根据具体的设备通信协议和需求进行更复杂的指令编写和数据交互。
（三）移动设备与外接配件
如今，手机、平板电脑等移动设备已成为人们生活中不可或缺的工具。为了满足用户多样化的需求，移动设备与各种外接配件的连接越来越普遍。比如，通过连接外接摄像头提升拍摄质量，连接游戏手柄获得更好的游戏体验，连接移动硬盘扩展存储容量等。
移动设备与外接配件的连接通常借助特定的协议，如 USB On - The - Go（OTG）协议、蓝牙协议等。以手机通过 OTG 连接外接键盘为例，当手机检测到外接键盘接入时，系统会自动识别并加载相应的驱动程序。此时，手机软件能够将键盘输入的信号转换为相应的字符或指令，实现与在手机自带键盘上输入相同的效果。
在 Android 开发中，使用 Android Open Accessory（AOA）协议可以实现 Android 设备与配件的双向通信。首先在AndroidManifest.xml中声明权限：
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.accessoryapp">
<uses - feature android:name="android.hardware.usb.host" />
<uses - permission android:name="android.permission.USB_PERMISSION" />
</manifest>然后在代码中获取 USB 配件设备并连接：
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.hardware.usb.UsbAccessory;
import android.hardware.usb.UsbManager;
import android.os.Bundle;
import android.os.ParcelFileDescriptor;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class MainActivity extends AppCompatActivity {
private static final String ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION";
private UsbManager usbManager;
private UsbAccessory accessory;
private ParcelFileDescriptor pfd;
private FileInputStream inputStream;
private FileOutputStream outputStream;
private final BroadcastReceiver usbReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (ACTION_USB_PERMISSION.equals(action)) {
synchronized (this) {
boolean granted = intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false);
if (granted) {
if (accessory!= null) {
openAccessory(accessory);
}
} else {
Toast.makeText(context, "USB权限未授予", Toast.LENGTH_SHORT).show();
}
}
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
usbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
registerReceiver(usbReceiver, filter);
UsbAccessory[] accessories = usbManager.getAccessoryList();
if (accessories!= null) {
for (UsbAccessory acc : accessories) {
if (/* 根据实际情况筛选配件 */true) {
accessory = acc;
break;
}
}
}
if (accessory!= null) {
if (usbManager.hasPermission(accessory)) {
openAccessory(accessory);
} else {
PendingIntent permissionIntent = PendingIntent.getBroadcast(this, 0, new Intent(ACTION_USB_PERMISSION), 0);
usbManager.requestPermission(accessory, permissionIntent);
}
}
}
private void openAccessory(UsbAccessory accessory) {
pfd = usbManager.openAccessory(accessory);
if (pfd!= null) {
try {
inputStream = new FileInputStream(pfd.getFileDescriptor());
outputStream = new FileOutputStream(pfd.getFileDescriptor());
// 这里可以进行数据的读写操作
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Override
protected void onDestroy() {
super.onDestroy();
unregisterReceiver(usbReceiver);
if (pfd!= null) {
try {
pfd.close();
inputStream.close();
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}通过上述代码，实现了 Android 设备与外接配件的连接及数据交互准备，在实际应用中，可以根据外接配件的功能进行具体的数据读写操作。
三、Java 实现硬件连接的技术手段
（一）网络通信协议
在 Java 编程中，网络通信协议是实现硬件与软件连接的重要桥梁，其中 TCP/IP 协议和 UDP 协议应用最为广泛。
1.TCP/IP 协议
TCP/IP 协议是互联网的基础协议，它提供了可靠的、面向连接的数据传输服务。在 Java 中，通过java.net包中的Socket和ServerSocket类来实现 TCP 通信。
使用 TCP/IP 协议进行通信时，首先要创建服务器端和客户端。服务器端通过ServerSocket监听指定端口，等待客户端的连接请求。例如：
import java.io.IOException;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class TCPServer {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(8888);
System.out.println("服务器已启动，等待客户端连接...");
Socket clientSocket = serverSocket.accept();
System.out.println("客户端已连接");
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.print("请输入要发送给客户端的消息: ");
String message = scanner.nextLine();
out.println(message);
if ("exit".equals(message)) {
break;
}
}
clientSocket.close();
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}客户端则使用Socket类连接到服务器端的指定 IP 地址和端口。如下：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
public class TCPClient {
public static void main(String[] args) {
try {
Socket socket = new Socket("127.0.0.1", 8888);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String message;
while ((message = in.readLine())!= null) {
System.out.println("收到服务器消息: " + message);
if ("exit".equals(message)) {
break;
}
}
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}在上述代码中，服务器端监听 8888 端口，当客户端连接成功后，双方可以进行数据的发送和接收。这种方式确保了数据的可靠传输，适合对数据准确性要求较高的场景，如文件传输、数据库连接等。
2.UDP 协议
UDP 协议是一种无连接的协议，它不保证数据的可靠传输，但具有传输速度快、开销小的特点。在 Java 中，通过java.net包中的DatagramSocket和DatagramPacket类实现 UDP 通信。
以下是一个简单的 UDP 通信示例，包括发送端和接收端：
发送端代码：
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class UDPSender {
public static void main(String[] args) {
try {
DatagramSocket socket = new DatagramSocket();
InetAddress address = InetAddress.getByName("127.0.0.1");
String message = "Hello, UDP!";
byte[] buffer = message.getBytes();
DatagramPacket packet = new DatagramPacket(buffer, buffer.length, address, 9999);
socket.send(packet);
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}接收端代码：
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class UDPReceiver {
public static void main(String[] args) {
try {
DatagramSocket socket = new DatagramSocket(9999);
byte[] buffer = new byte[1024];
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
socket.receive(packet);
String receivedMessage = new String(packet.getData(), 0, packet.getLength());
System.out.println("收到UDP消息: " + receivedMessage);
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}在这个例子中，发送端将数据打包成DatagramPacket，并发送到指定的 IP 地址和端口。接收端在相应端口监听，接收到数据包后进行处理。UDP 协议适用于对实时性要求较高、对数据准确性要求相对较低的场景，如视频直播、音频传输、网络游戏中的实时数据传输等 。例如，在视频直播中，偶尔丢失一些数据帧可能只会导致画面出现短暂的卡顿，但不会影响整体的观看体验，而 UDP 的快速传输特性则能保证直播的流畅性。
（二）串口通信
串口通信是一种常用的硬件与软件连接方式，在工业控制、嵌入式系统等领域广泛应用。在 Java 中，由于其本身没有内置对串口的支持，需要借助第三方库来实现串口通信，如JSerialComm库。
使用JSerialComm库进行串口通信，首先要在项目中添加依赖。如果使用 Maven 构建项目，在pom.xml文件中添加如下依赖：
<dependency>
<groupId>com.fazecast</groupId>
<artifactId>jSerialComm</artifactId>
<version>2.8.0</version>
</dependency>然后编写代码实现串口的打开、数据发送和接收。例如，向串口设备发送数据的代码如下：
import com.fazecast.jSerialComm.SerialPort;
public class SerialCommunication {
public static void main(String[] args) {
SerialPort serialPort = SerialPort.getCommPort("COM1");// 根据实际端口修改
if (serialPort.openPort()) {
String dataToSend = "Hello, Serial Port!";
byte[] data = dataToSend.getBytes();
int bytesWritten = serialPort.writeBytes(data, data.length);
if (bytesWritten == data.length) {
System.out.println("数据发送成功");
} else {
System.out.println("数据发送失败");
}
serialPort.closePort();
} else {
System.out.println("无法打开串口");
}
}
}在上述代码中，首先通过SerialPort.getCommPort("COM1")获取指定的串口对象，然后使用openPort()方法打开串口。若打开成功，将需要发送的数据转换为字节数组，并通过writeBytes()方法将数据写入串口。最后，关闭串口。
接收串口数据时，可以通过设置事件监听器来实现实时接收。示例代码如下：
import com.fazecast.jSerialComm.SerialPort;
import com.fazecast.jSerialComm.SerialPortDataListener;
import com.fazecast.jSerialComm.SerialPortEvent;
public class SerialReceiver {
public static void main(String[] args) {
SerialPort serialPort = SerialPort.getCommPort("COM1");// 根据实际端口修改
if (serialPort.openPort()) {
serialPort.addDataListener(new SerialPortDataListener() {
@Override
public int getListeningEvents() {
return SerialPort.LISTENING_EVENT_DATA_AVAILABLE;
}
@Override
public void serialEvent(SerialPortEvent event) {
if (event.getEventType() == SerialPort.LISTENING_EVENT_DATA_AVAILABLE) {
byte[] newData = new byte[event.getSerialPort().bytesAvailable()];
int numRead = event.getSerialPort().readBytes(newData, newData.length);
String receivedData = new String(newData, 0, numRead);
System.out.println("接收到串口数据: " + receivedData);
}
}
});
} else {
System.out.println("无法打开串口");
}
}
}在这段代码中，通过addDataListener()方法为串口添加数据监听器，当有数据可用时（LISTENING_EVENT_DATA_AVAILABLE事件触发），监听器的serialEvent()方法会被调用，在该方法中读取并处理接收到的数据。
（三）USB 通信
USB 通信具有高速、便捷、即插即用等优点，在现代设备连接中应用广泛。在 Java 中，与 USB 设备通信的实现相对复杂，通常需要借助 Java 的javax.usb库（需要额外导入相关依赖）或特定的 USB 设备厂商提供的 SDK。
以使用javax.usb库为例，要实现与 USB 设备的通信，首先要确保系统中已经正确安装了 USB 设备的驱动程序。然后在项目中添加javax.usb库的依赖。例如，在 Maven 项目中，可以在pom.xml文件中添加如下依赖（假设使用的是合适的版本）：
<dependency>
<groupId>net.java.dev.jusb</groupId>
<artifactId>usb</artifactId>
<version>1.0.0</version>
</dependency>接下来，通过以下代码实现对 USB 设备的查找和连接：
import javax.usb.*;
import java.util.List;
public class USBCommunication {
public static void main(String[] args) {
UsbServices usbServices;
try {
usbServices = UsbHostManager.getUsbServices();
UsbHub rootHub = usbServices.getRootUsbHub();
findAndConnectDevice(rootHub);
} catch (UsbException e) {
e.printStackTrace();
}
}
private static void findAndConnectDevice(UsbHub hub) throws UsbException {
List<UsbDevice> devices = hub.getAttachedUsbDevices();
for (UsbDevice device : devices) {
if (device.isUsbHub()) {
findAndConnectDevice((UsbHub) device);
} else {
// 假设这里判断找到目标USB设备
if (isTargetDevice(device)) {
UsbDeviceConnection connection = device.open();
// 这里可以进行数据传输操作，例如：
UsbEndpoint outEndpoint = getOutEndpoint(device);
byte[] dataToSend = "Hello, USB Device!".getBytes();
connection.controlTransfer(UsbConst.REQUEST_TYPE_CLASS | UsbConst.RECIPIENT_INTERFACE,
UsbConst.CTRL_SET_CONFIGURATION, 0, 0, dataToSend, dataToSend.length, 0);
connection.close();
}
}
}
}
private static boolean isTargetDevice(UsbDevice device) {
// 根据设备的vendor ID和product ID等信息判断是否为目标设备
return device.getVendorId() == 1234 && device.getProductId() == 5678;
}
private static UsbEndpoint getOutEndpoint(UsbDevice device) throws UsbException {
UsbConfiguration configuration = device.getActiveUsbConfiguration();
UsbInterface iface = configuration.getUsbInterface(0);
UsbInterfaceSetting setting = iface.getUsbInterfaceSetting(0);
for (UsbEndpoint endpoint : setting.getUsbEndpoints()) {
if (endpoint.getType() == UsbConst.ENDPOINT_TYPE_BULK && endpoint.getDirection() == UsbConst.ENDPOINT_DIRECTION_OUT) {
return endpoint;
}
}
return null;
}
}在上述代码中，首先通过UsbHostManager.getUsbServices()获取 USB 服务，然后从根 USB 集线器开始递归查找所有连接的 USB 设备。当找到目标设备后，打开设备连接，并获取输出端点进行数据传输 。在实际应用中，需要根据具体的 USB 设备类型和通信协议，对数据传输的方式和内容进行相应的调整。例如，对于不同类型的 USB 设备，其端点的类型、数量和功能可能不同，需要根据设备的规格说明书来正确配置和使用端点。
四、代码示例展示
（一）智能家居灯光控制
在智能家居场景中，以控制智能灯泡为例，下面为你展示 Java 代码实现软件与硬件的连接及控制过程。这里假设智能灯泡支持 HTTP 协议进行控制，通过发送 HTTP 请求来实现对灯泡的开关、亮度调节等操作。
首先，创建一个LightController类，用于封装与智能灯泡交互的方法：
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
public class LightController {
private String ipAddress;
public LightController(String ipAddress) {
this.ipAddress = ipAddress;
}
// 打开灯光
public void turnOn() throws Exception {
String requestUrl = "http://" + ipAddress + "/turnOn";
sendHttpRequest(requestUrl);
}
// 关闭灯光
public void turnOff() throws Exception {
String requestUrl = "http://" + ipAddress + "/turnOff";
sendHttpRequest(requestUrl);
}
// 调节亮度
public void adjustBrightness(int level) throws Exception {
String requestUrl = "http://" + ipAddress + "/adjustBrightness?level=" + level;
sendHttpRequest(requestUrl);
}
private void sendHttpRequest(String requestUrl) throws Exception {
URL url = new URL(requestUrl);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setDoOutput(true);
try (OutputStream os = conn.getOutputStream()) {
os.write("".getBytes());
}
int responseCode = conn.getResponseCode();
if (responseCode!= HttpURLConnection.HTTP_OK) {
throw new Exception("请求失败，响应码：" + responseCode);
}
}
}在上述代码中，LightController类通过构造函数接收智能灯泡的 IP 地址 。turnOn、turnOff和adjustBrightness方法分别用于打开灯光、关闭灯光和调节亮度，它们通过拼接 HTTP 请求 URL，并调用sendHttpRequest方法来发送请求。sendHttpRequest方法负责创建 HTTP 连接，设置请求方法和输出流，发送请求并检查响应码。
然后，在main方法中测试LightController类的功能：
public class Main {
public static void main(String[] args) {
String bulbIpAddress = "192.168.1.100";// 根据实际情况修改
LightController lightController = new LightController(bulbIpAddress);
try {
lightController.turnOn();
System.out.println("灯光已打开");
lightController.adjustBrightness(80);
System.out.println("亮度已调节为80");
lightController.turnOff();
System.out.println("灯光已关闭");
} catch (Exception e) {
e.printStackTrace();
}
}
}在main方法中，首先创建LightController对象，并传入智能灯泡的 IP 地址。然后依次调用turnOn、adjustBrightness和turnOff方法，实现对智能灯泡的控制，并在控制台输出相应的操作结果。如果在操作过程中发生异常，将异常信息打印到控制台。
（二）工业设备数据采集
在工业领域，从传感器采集数据是实现工业自动化和智能化的基础。下面给出通过 Java 从工业传感器采集数据的代码示例，这里假设传感器通过串口与计算机连接，并使用JSerialComm库进行串口通信。
首先，在项目中添加JSerialComm库的依赖（如果使用 Maven，在pom.xml文件中添加）：
<dependency>
<groupId>com.fazecast</groupId>
<artifactId>jSerialComm</artifactId>
<version>2.8.0</version>
</dependency>然后，编写SensorDataCollector类来实现数据采集功能：
import com.fazecast.jSerialComm.SerialPort;
import com.fazecast.jSerialComm.SerialPortDataListener;
import com.fazecast.jSerialComm.SerialPortEvent;
public class SensorDataCollector {
private SerialPort serialPort;
public SensorDataCollector(String portName) {
serialPort = SerialPort.getCommPort(portName);
if (!serialPort.openPort()) {
throw new RuntimeException("无法打开串口：" + portName);
}
serialPort.addDataListener(new SerialPortDataListener() {
@Override
public int getListeningEvents() {
return SerialPort.LISTENING_EVENT_DATA_AVAILABLE;
}
@Override
public void serialEvent(SerialPortEvent event) {
if (event.getEventType() == SerialPort.LISTENING_EVENT_DATA_AVAILABLE) {
byte[] newData = new byte[event.getSerialPort().bytesAvailable()];
int numRead = event.getSerialPort().readBytes(newData, newData.length);
String receivedData = new String(newData, 0, numRead);
System.out.println("接收到传感器数据：" + receivedData);
// 这里可以对数据进行进一步处理，如存储到数据库等
}
}
});
}
public void close() {
if (serialPort!= null && serialPort.isOpen()) {
serialPort.closePort();
}
}
}在SensorDataCollector类中，构造函数接收串口名称作为参数，尝试打开指定的串口。如果打开失败，抛出运行时异常。通过addDataListener方法为串口添加数据监听器，当有数据可用时，监听器的serialEvent方法会被调用，在该方法中读取接收到的数据，并在控制台打印出来，同时可以根据实际需求对数据进行进一步处理，如存储到数据库等。close方法用于关闭串口。
最后，在main方法中使用SensorDataCollector类进行数据采集：
public class Main {
public static void main(String[] args) {
String serialPortName = "COM1";// 根据实际情况修改
SensorDataCollector collector = new SensorDataCollector(serialPortName);
try {
// 保持程序运行，以便持续接收数据
Thread.sleep(1000000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
collector.close();
}
}
}在main方法中，创建SensorDataCollector对象，传入实际的串口名称。通过Thread.sleep方法使程序保持运行状态，以便持续接收传感器数据。在程序结束时，调用collector.close()方法关闭串口。
原文地址：https://blog.csdn.net/m0_73978383/article/details/145160957
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！