1
public static void ShotFrame(String fileName) throws AWTException, IOException {
2
        Integer x = Integer.valueOf(PropertiesHelper.getValue(窗口X));
3

4
        Integer y = Integer.valueOf(PropertiesHelper.getValue(窗口Y));
5

6
        Integer height = Integer.valueOf(PropertiesHelper.getValue(窗口高度));
7

8
        Integer width = Integer.valueOf(PropertiesHelper.getValue(窗口宽度));
9

10
        //创建一个robot对象
11
        Robot robut = new Robot();
12
        //获取屏幕分辨率
13
        //打印屏幕分辨率
14
        //创建该分辨率的矩形对象
15
        Dimension act=new Dimension();
16
        act.setSize(width,height);
17
        Point point=new Point(x,y);
18
        Rectangle screenRect = new Rectangle(point,act);
19
        //根据这个矩形截图
20
        BufferedImage bufferedImage = robut.createScreenCapture(screenRect);
21
        //保存截图
22
        File file = new File("D:\\maplePic\\"+fileName+".jpg");
23
        ImageIO.write(bufferedImage, "jpg", file);
24
    }

1
    /**
2
     * OpenCV-4.0.0 直方图比较
3
     *
4
     * @return: double 两张图片的相似值
5
     */
6
    public static double compareHist_2(String resource, String now) {
7
        Mat src_1 = imread("D:\\maplePic\\"+resource+".jpg");// 图片 1
8
        Mat src_2 = imread("D:\\maplePic\\"+now+".jpg");// 图片 2
9

10
        Mat hvs_1 = new Mat();
11
        Mat hvs_2 = new Mat();
12
        //图片转HSV
13
        cvtColor(src_1, hvs_1,COLOR_BGR2HSV);
14
        cvtColor(src_2, hvs_2,COLOR_BGR2HSV);
15

16
        Mat hist_1 = new Mat();
17
        Mat hist_2 = new Mat();
18

19

20
        final int[] channels = new int[]{0, 1, 2};
21

22
        final int[] histSize = new int[]{8, 8, 8};
23
        final float[] histRange = new float[]{0f, 255f};
24
        IntPointer intPtrChannels = new IntPointer(channels);
25
        IntPointer intPtrHistSize = new IntPointer(histSize);
26
        final PointerPointer<FloatPointer> ptrPtrHistRange = new PointerPointer<>(histRange, histRange, histRange);
27
        calcHist(hvs_1, 1, intPtrChannels, new Mat(), hist_1, 3, intPtrHistSize, ptrPtrHistRange, true, false);
28
        calcHist(hvs_2, 1, intPtrChannels, new Mat(), hist_2, 3, intPtrHistSize, ptrPtrHistRange, true, false);
29

30

31
        //图片归一化
32
        normalize(hist_1, hist_1, 1, hist_1.rows() , NORM_MINMAX, -1, new Mat() );
33
        normalize(hist_2, hist_2, 1, hist_2.rows() , NORM_MINMAX, -1, new Mat() );
34

35
        //直方图比较
36
        return compareHist(hist_1,hist_2,CV_COMP_CORREL);
37
    }

1
public class SerialPortTool {
2

3
    /**
4
     * 查找电脑上所有可用 com 端口
5
     *
6
     * @return 可用端口名称列表，没有时 列表为空
7
     */
8
    public static final ArrayList<String> findSystemAllComPort() {
9
        /**
10
         *  getPortIdentifiers：获得电脑主板当前所有可用串口
11
         */
12
        Enumeration<CommPortIdentifier> portList = CommPortIdentifier.getPortIdentifiers();
13
        ArrayList<String> portNameList = new ArrayList<>();
14

15
        /**
16
         *  将可用串口名添加到 List 列表
17
         */
18
        while (portList.hasMoreElements()) {
19
            String portName = portList.nextElement().getName();//名称如 COM1、COM2....
20
            portNameList.add(portName);
21
        }
22
        return portNameList;
23
    }
24

25
    /**
26
     * 打开电脑上指定的串口
27
     *
28
     * @param portName 端口名称，如 COM1，为 null 时，默认使用电脑中能用的端口中的第一个
29
     * @param b        波特率(baudrate)，如 9600
30
     * @param d        数据位（datebits），如 SerialPort.DATABITS_8 = 8
31
     * @param s        停止位（stopbits），如 SerialPort.STOPBITS_1 = 1
32
     * @param p        校验位 (parity)，如 SerialPort.PARITY_NONE = 0
33
     * @return 打开的串口对象，打开失败时，返回 null
34
     */
35
    public static final SerialPort openComPort(String portName, int b, int d, int s, int p) {
36
        CommPort commPort = null;
37
        try {
38
            //当没有传入可用的 com 口时，默认使用电脑中可用的 com 口中的第一个
39
            if (portName == null || "".equals(portName)) {
40
                List<String> comPortList = findSystemAllComPort();
41
                if (comPortList != null && comPortList.size() > 0) {
42
                    portName = comPortList.get(0);
43
                }
44
            }
45
//            System.out.println("开始打开串口：portName=" + portName + ",baudrate=" + b + ",datebits=" + d + ",stopbits=" + s + ",parity=" + p);
46
            //通过端口名称识别指定 COM 端口
47
            CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
48
            /**
49
             * open(String TheOwner, int i)：打开端口
50
             * TheOwner 自定义一个端口名称，随便自定义即可
51
             * i：打开的端口的超时时间，单位毫秒，超时则抛出异常：PortInUseException if in use.
52
             * 如果此时串口已经被占用，则抛出异常：gnu.io.PortInUseException: Unknown Application
53
             */
54
            commPort = portIdentifier.open(portName, 5000);
55
            /**
56
             * 判断端口是不是串口
57
             * public abstract class SerialPort extends CommPort
58
             */
59
            if (commPort instanceof SerialPort) {
60
                SerialPort serialPort = (SerialPort) commPort;
61
                /**
62
                 * 设置串口参数：setSerialPortParams( int b, int d, int s, int p )
63
                 * b：波特率（baudrate）
64
                 * d：数据位（datebits），SerialPort 支持 5,6,7,8
65
                 * s：停止位（stopbits），SerialPort 支持 1,2,3
66
                 * p：校验位 (parity)，SerialPort 支持 0,1,2,3,4
67
                 * 如果参数设置错误，则抛出异常：gnu.io.UnsupportedCommOperationException: Invalid Parameter
68
                 * 此时必须关闭串口，否则下次 portIdentifier.open 时会打不开串口，因为已经被占用
69
                 */
70
                serialPort.setSerialPortParams(b, d, s, p);
71
//                System.out.println("打开串口 " + portName + " 成功...");
72
                return serialPort;
73
            } else {
74
                System.out.println("当前端口 " + commPort.getName() + " 不是串口...");
75
            }
76
        } catch (NoSuchPortException e) {
77
            e.printStackTrace();
78
        } catch (PortInUseException e) {
79
            System.out.println("串口 " + portName + " 已经被占用，请先解除占用...");
80
            e.printStackTrace();
81
        } catch (UnsupportedCommOperationException e) {
82
            System.out.println("串口参数设置错误，关闭串口，数据位[5-8]、停止位[1-3]、验证位[0-4]...");
83
            e.printStackTrace();
84
            if (commPort != null) {//此时必须关闭串口，否则下次 portIdentifier.open 时会打不开串口，因为已经被占用
85
                commPort.close();
86
            }
87
        }
88
        System.out.println("打开串口 " + portName + " 失败...");
89
        return null;
90
    }
91

92
    /**
93
     * 往串口发送数据
94
     *
95
     * @param serialPort 串口对象
96
     * @param order      待发送数据
97
     */
98
    public static void sendDataToComPort(SerialPort serialPort, byte[] orders) {
99
        OutputStream outputStream = null;
100
        try {
101
            if (serialPort != null) {
102
                outputStream = serialPort.getOutputStream();
103
                outputStream.write(orders);
104
                outputStream.flush();
105
//                System.out.println("往串口 " + serialPort.getName() + " 发送数据：" + Arrays.toString(orders) + " 完成...");
106
            } else {
107
                System.out.println("gnu.io.SerialPort 为null，取消数据发送...");
108
            }
109
        } catch (IOException e) {
110
            e.printStackTrace();
111
        } finally {
112
            if (outputStream != null) {
113
                try {
114
                    outputStream.close();
115
                } catch (IOException e) {
116
                    e.printStackTrace();
117
                }
118
            }
119
        }
120
    }
121

122
    /**
123
     * 往串口发送数据
124
     *
125
     * @param serialPort 串口对象
126
     */
127
    public static String readDataToComPort(SerialPort serialPort) {
128

129
        try (InputStream inputStream = serialPort.getInputStream(); ByteArrayOutputStream byteArrayOutputStream=new ByteArrayOutputStream()) {
130
            byte[] a=new byte[1024];
131
            while (inputStream.read(a)>0){
132
                byteArrayOutputStream.write(a);
133
            }
134
            return byteArrayOutputStream.toString();
135
        } catch (IOException e) {
136
            e.printStackTrace();
137
        }
138
        return "";
139
    }
140

141
    /**
142
     * 关闭串口
143
     *
144
     * @param serialport 待关闭的串口对象
145
     */
146
    public static void closeComPort(SerialPort serialPort) {
147
        if (serialPort != null) {
148
            serialPort.close();
149
//            System.out.println("关闭串口 " + serialPort.getName());
150
        }
151
    }
152

153
    /**
154
     * 16进制字符串转十进制字节数组
155
     * 这是常用的方法，如某些硬件的通信指令就是提供的16进制字符串，发送时需要转为字节数组再进行发送
156
     *
157
     * @param strSource 16进制字符串，如 "455A432F5600"，每两位对应字节数组中的一个10进制元素
158
     *                  默认会去除参数字符串中的空格，所以参数 "45 5A 43 2F 56 00" 也是可以的
159
     * @return 十进制字节数组, 如 [69, 90, 67, 47, 86, 0]
160
     */
161
    public static byte[] hexString2Bytes(String strSource) {
162
        if (strSource == null || "".equals(strSource.trim())) {
163
            System.out.println("hexString2Bytes 参数为空，放弃转换.");
164
            return null;
165
        }
166
        strSource = strSource.replace(" ", "");
167
        int l = strSource.length() / 2;
168
        byte[] ret = new byte[l];
169
        for (int i = 0; i < l; i++) {
170
            ret[i] = Integer.valueOf(strSource.substring(i * 2, i * 2 + 2), 16).byteValue();
171
        }
172
        return ret;
173
    }
174

175
    public static void main(String[] args) {
176
//        //发送普通数据
177
        byte[] bytes = new byte[]{0x31};
178
        SerialPort serialPort = SerialPortTool.openComPort("COM5", 9600, 8, 1, 0);
179
        SerialPortTool.sendDataToComPort(serialPort, bytes);
180
        String s = SerialPortTool.readDataToComPort(serialPort);
181
        System.out.println(s);
182
        SerialPortTool.closeComPort(serialPort);
183
    }
184
}

1
 public static void main(String[] args) {
2
        //每秒一次
3
        Timer timer = new Timer();
4
        TimerTask timerTask = new TimerTask() {
5
            @Override
6
            public void run() {
7
                try {
8
                    lhbrother();
9
                } catch (IOException e) {
10
                    e.printStackTrace();
11
                } catch (AWTException e) {
12
                    e.printStackTrace();
13
                } catch (InterruptedException e) {
14
                    e.printStackTrace();
15
                }
16
            }
17
        };
18
        // 第一次任务延迟时间
19
        long delay = 2000;
20

21
        // 任务执行频率
22
        long period = 1000;
23

24
        // 开始调度
25
        timer.schedule(timerTask, delay, period);
26

27
    }
28
    public static void lhbrother() throws IOException, AWTException, InterruptedException {
29
        //截图生成结果
30
        ScreenShotUtil.Shot1("n1");
31
        if(OpenCvUtil.compareHist_2("n1","1")>0.90){
32
            System.out.println("1冷却完毕");
33
            Random random=new Random();
34
            Thread.sleep(random.nextInt(500)+500);
35
            //这里发送的是ascii码，Arduino读取串口后直接KeyBorad.Press读到的内容即可。
36
            //因为ascii码没有上下左右等方向键，所以如果需要控制上下走动，可以使用一个特殊的ascii码，然后在Arduino代码里特殊判断下
37
            byte[] bytes = new byte[]{0x31};
38
            SerialPort serialPort = SerialPortTool.openComPort("COM5", 9600, 8, 1, 0);
39
            SerialPortTool.sendDataToComPort(serialPort, bytes);
40
            String s = SerialPortTool.readDataToComPort(serialPort);
41
            System.out.println(s);
42
            SerialPortTool.closeComPort(serialPort);
43
            return ;
44
        }
45
    }