IoT_2021_

.gitignore

@@ -0,0 +1,36 @@
+HELP.md
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+.mvn
+mvnw
+mvnw.cmd
+Nstthh.iml
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/

package.json

@@ -0,0 +1,6 @@
+{
+  "name": "Nstthh",
+  "version": "1.0.0",
+  "dependencies": {
+  }
+}

pom.xml

@@ -0,0 +1,90 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>2.6.1</version>
+        <relativePath/> <!-- lookup parent from repository -->
+    </parent>
+    <groupId>com.sjls</groupId>
+    <artifactId>Nstthh</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>Nstthh</name>
+    <description>Nstthh</description>
+    <properties>
+        <java.version>1.8</java.version>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-jpa</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.neuronrobotics</groupId>
+            <artifactId>nrjavaserial</artifactId>
+            <version>5.1.1</version>
+        </dependency>
+
+        <dependency>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-all</artifactId>
+            <version>5.7.17</version>
+        </dependency>
+
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-actuator</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.testng</groupId>
+            <artifactId>testng</artifactId>
+            <version>RELEASE</version>
+            <scope>compile</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <configuration>
+                    <excludes>
+                        <exclude>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                        </exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+
+        </plugins>
+    </build>
+
+</project>

src/main/java/com/sjls/nstthh/NstthhApplication.java

@@ -0,0 +1,31 @@
+package com.sjls.nstthh;
+
+
+import com.sjls.nstthh.usb.NRJavaSerialService;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+
+@SpringBootApplication
+
+public class NstthhApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(NstthhApplication.class, args);
+
+//        System.out.println(" Hello world java pi ......" );
+//        for (String s: NRSerialPort.getAvailableSerialPorts()){
+//            System.out.println("Availible port = " + s);
+//        }
+
+        try {
+            NRJavaSerialService nRJavaSerialService = new NRJavaSerialService();
+            nRJavaSerialService.connect("/dev/ttyUSB0");// /dev/ttyUSB0
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+}

src/main/java/com/sjls/nstthh/controller/HardwareAdmin.java

@@ -0,0 +1,19 @@
+package com.sjls.nstthh.controller;
+
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * smp admin
+ */
+
+@RestController
+public class HardwareAdmin {
+
+    @RequestMapping("/hello")
+    public String index() {
+        return "Hello World";
+    }
+
+}
+

src/main/java/com/sjls/nstthh/entity/CommunicationData.java

@@ -0,0 +1,52 @@
+package com.sjls.nstthh.entity;
+
+
+import lombok.Data;
+
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import java.util.Date;
+
+
+/**
+ * 通讯数据
+ */
+
+@Data
+@Entity
+public class CommunicationData {
+    @Id //主键
+    @GeneratedValue(strategy = GenerationType.IDENTITY)//自增
+
+    private Long id;
+
+
+    private long sendId;
+    private long receiveId;
+
+
+    private String sendAKey; //12345678;029B029B
+    private String receiveKey; //12345678;029B029B
+
+    // private String heartbeatData;
+
+    private String deviceid; //12345678
+    private String distance; //00000989
+//    private String anglez;//截取角度 029B
+//    private String angley;//截取角度 029B
+
+    private String groupVal; //组
+    private Date creatDate;
+
+
+    public static void main(String[] args) {
+
+        //68220185000000E08812345678031101B50102029B029B0000048600FF7B123456781C7016
+        String str = "681C0105000000CD9612345678031101A5010203E803E80012345678149B16";  //38 , 46
+        System.out.println("args = " + str.getBytes().length);
+
+        System.out.println("args = " + str.length());
+    }
+}

src/main/java/com/sjls/nstthh/entity/Equipment.java

@@ -0,0 +1,22 @@
+package com.sjls.nstthh.entity;
+
+import lombok.Data;
+
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+
+/**
+ * dpj
+ */
+@Data
+@Entity
+public class Equipment {
+    @Id //主键
+    @GeneratedValue(strategy = GenerationType.IDENTITY)//自增
+    private Long id;
+
+    private String emTitle;
+
+}

src/main/java/com/sjls/nstthh/entity/ReceiveData.java

@@ -0,0 +1,19 @@
+package com.sjls.nstthh.entity;
+
+import lombok.Data;
+
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+
+@Data
+@Entity
+public class ReceiveData {
+    @Id //主键
+    @GeneratedValue(strategy = GenerationType.IDENTITY)//自增
+    private Long id;
+
+
+    private String receiveStr;
+}

src/main/java/com/sjls/nstthh/entity/SendData.java

@@ -0,0 +1,19 @@
+package com.sjls.nstthh.entity;
+
+import lombok.Data;
+
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+
+@Data
+@Entity
+public class SendData {
+    @Id //主键
+    @GeneratedValue(strategy = GenerationType.IDENTITY)//自增
+    private Long id;
+
+    private String sendStr;
+
+}

src/main/java/com/sjls/nstthh/repository/CommunicationDataRepository.java

@@ -0,0 +1,11 @@
+package com.sjls.nstthh.repository;
+
+
+import com.sjls.nstthh.entity.CommunicationData;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+
+public interface CommunicationDataRepository extends JpaRepository<CommunicationData, Integer> {
+
+
+}

src/main/java/com/sjls/nstthh/repository/ReceiveDataRepository.java

@@ -0,0 +1,10 @@
+package com.sjls.nstthh.repository;
+
+
+import com.sjls.nstthh.entity.ReceiveData;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface ReceiveDataRepository extends JpaRepository<ReceiveData, Long> {
+
+
+}

src/main/java/com/sjls/nstthh/repository/SendDataRepository.java

@@ -0,0 +1,9 @@
+package com.sjls.nstthh.repository;
+
+import com.sjls.nstthh.entity.SendData;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface SendDataRepository extends JpaRepository<SendData, Long> {
+
+
+}

src/main/java/com/sjls/nstthh/usb/NRJavaSerialService.java

@@ -0,0 +1,244 @@
+package com.sjls.nstthh.usb;
+
+import com.sjls.nstthh.util.StrSplicingAssistant;
+import gnu.io.NRSerialPort;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/**
+ * x64 usb NRJavaSerial
+ * <p>
+ * SATA;COM;uart;Serial;usb
+ */
+
+@Component
+public class NRJavaSerialService {
+    private static final Logger logger = LoggerFactory.getLogger(NRJavaSerialService.class);
+    static ArrayList<String> sendStr = new ArrayList<String>();
+    private volatile static boolean isHeartbeat = false;
+    private volatile static boolean isReceive = false;
+
+    static {
+        sendStr.add("681C0105000000CD9612345678031101A50102087708230012345678843C16");
+        sendStr.add("681C0105000000CD9612345678031101A501020831082E0012345678013B16");
+        sendStr.add("681C0105000000CD9612345678031101A501020877083A0012345678863516");
+        sendStr.add("681C0105000000CD9612345678031101A501020387038A00123456785AB116");
+        sendStr.add("681C0105000000CD9612345678031101A50102087708170012345678804816");
+        sendStr.add("681C0105000000CD9612345678031101A501020827081D001234567885DE16");
+        sendStr.add("681C0105000000CD9612345678031101A5010207EE082B00123456780D8216");
+        sendStr.add("681C0105000000CD9612345678031101A5010207F8083D00123456788E5216");
+        sendStr.add("681C0105000000CD9612345678031101A501020877084600123456788DC916");
+        sendStr.add("681C0105000000CD9612345678031101A5010203C0037B00123456780A4616");
+        sendStr.add("681C0105000000CD9612345678031101A5010203CA038D00123456789EAF16");
+        sendStr.add("681C0105000000CD9612345678031101A501020391039B0012345678D8D616");
+        sendStr.add("681C0105000000CD9612345678031101A501020877080C001234567883A316");
+        sendStr.add("681C0105000000CD9612345678031101A50102082D080F001234567806D316");
+        sendStr.add("681C0105000000CD9612345678031101A5010207E90818001234567849A716");
+        sendStr.add("681C0105000000CD9612345678031101A5010207B20826001234567809F616");
+        sendStr.add("681C0105000000CD9612345678031101A50102079808380012345678882F16");
+        sendStr.add("681C0105000000CD9612345678031101A5010207C6084A0012345678064D16");
+        sendStr.add("681C0105000000CD9612345678031101A501020877085200123456788EDD16");
+        sendStr.add("681C0105000000CD9612345678031101A5010203F2036E00123456788A4E16");
+        sendStr.add("681C0105000000CD9612345678031101A5010204200380001234567837B516");
+        sendStr.add("681C0105000000CD9612345678031101A50102040603920012345678B6F516");
+        sendStr.add("681C0105000000CD9612345678031101A5010203CF03A0001234567858ED16");
+        sendStr.add("681C0105000000CD9612345678031101A50102038B03A900123456785DB716");
+        sendStr.add("681C0105000000CD9612345678031101A5010208770801001234567882BE16");
+        sendStr.add("681C0105000000CD9612345678031101A5010208360803001234567846A016");
+        sendStr.add("681C0105000000CD9612345678031101A5010207F6080800123456780A7B16");
+        sendStr.add("681C0105000000CD9612345678031101A5010207B9081200123456784C3116");
+        sendStr.add("681C0105000000CD9612345678031101A501020782081F00123456780F8B16");
+        sendStr.add("681C0105000000CD9612345678031101A501020755082F001234567846C116");
+        sendStr.add("681C0105000000CD9612345678031101A501020741084100123456784EB016");
+        sendStr.add("681C0105000000CD9612345678031101A50102076B08530012345678CFA516");
+        sendStr.add("681C0105000000CD9612345678031101A50102083C085E0012345678CB9216");
+        sendStr.add("681C0105000000CD9612345678031101A50102041B03600012345678637216");
+        sendStr.add("681C0105000000CD9612345678031101A50102047203700012345678A7A016");
+        sendStr.add("681C0105000000CD9612345678031101A50102046E03830012345678B23A16");
+        sendStr.add("681C0105000000CD9612345678031101A50102044803930012345678329816");
+        sendStr.add("681C0105000000CD9612345678031101A50102041403A2001234567833D016");
+        sendStr.add("681C0105000000CD9612345678031101A5010203D903AC0012345678D90716");
+        sendStr.add("681C0105000000CD9612345678031101A50102039A03B400123456789EFA16");
+        sendStr.add("681C0105000000CD9612345678031101A50102087707F5001234567868CA16");
+        sendStr.add("681C0105000000CD9612345678031101A50102083A07F70012345678AC8116");
+        sendStr.add("681C0105000000CD9612345678031101A5010207FE07FB0012345678E01E16");
+        sendStr.add("681C0105000000CD9612345678031101A5010207C20803001234567809E716");
+        sendStr.add("681C0105000000CD9612345678031101A501020788080D00123456788C8616");
+        sendStr.add("681C0105000000CD9612345678031101A50102075008190012345678836816");
+        sendStr.add("681C0105000000CD9612345678031101A50102071B08290012345678C31B16");
+        sendStr.add("681C0105000000CD9612345678031101A5010206EF083A0012345678C29F16");
+        sendStr.add("681C0105000000CD9612345678031101A5010206D5084C00123456784AA216");
+        sendStr.add("681C0105000000CD9612345678031101A5010206FA085F00123456780A5916");
+        sendStr.add("681C0105000000CD9612345678031101A501020877086B00123456788BB416");
+        sendStr.add("681C0105000000CD9612345678031101A5010204BE03590012345678AC5C16");
+        sendStr.add("681C0105000000CD9612345678031101A5010204E3036C00123456786D5C16");
+        sendStr.add("681C0105000000CD9612345678031101A5010204C9037E0012345678EC4916");
+        sendStr.add("681C0105000000CD9612345678031101A50102049D038F0012345678FDA716");
+        sendStr.add("681C0105000000CD9612345678031101A501020468039F0012345678304C16");
+        sendStr.add("681C0105000000CD9612345678031101A50102043003AB001234567830A216");
+        sendStr.add("681C0105000000CD9612345678031101A5010203F603B50012345678995616");
+        sendStr.add("681C0105000000CD9612345678031101A5010203BA03BD00123456789C7B16");
+        sendStr.add("681C0105000000CD9612345678031101A50102037E03C100123456789A2416");
+        sendStr.add("681C0105000000CD9612345678031101A50102087707EA00123456786AA516");
+        sendStr.add("681C0105000000CD9612345678031101A50102083F07EC00123456786F5516");
+        sendStr.add("681C0105000000CD9612345678031101A50102080807EF00123456782D9416");
+        sendStr.add("681C0105000000CD9612345678031101A5010207D007F5001234567862A416");
+        sendStr.add("681C0105000000CD9612345678031101A50102079807FC001234567867AB16");
+        sendStr.add("681C0105000000CD9612345678031101A5010207610806001234567843DF16");
+        sendStr.add("681C0105000000CD9612345678031101A50102072908120012345678455D16");
+        sendStr.add("681C0105000000CD9612345678031101A5010206F2081F0012345678053F16");
+        sendStr.add("681C0105000000CD9612345678031101A5010206BA082F0012345678055916");
+        sendStr.add("681C0105000000CD9612345678031101A501020683083F0012345678C4B716");
+        sendStr.add("681C0105000000CD9612345678031101A50102064B08510012345678C1CF16");
+        sendStr.add("681C0105000000CD9612345678031101A50102061208640012345678013C16");
+        sendStr.add("681C0105000000CD9612345678031101A5010205DC05DC00123456785FA816");
+        sendStr.add("681C0105000000CD9612345678031101A5010205A603540012345678A07B16");
+        sendStr.add("681C0105000000CD9612345678031101A50102056D03670012345678E85B16");
+        sendStr.add("681C0105000000CD9612345678031101A50102053503790012345678EF7F16");
+        sendStr.add("681C0105000000CD9612345678031101A5010204FE03890012345678BBFC16");
+        sendStr.add("681C0105000000CD9612345678031101A5010204C603990012345678BBDE16");
+        sendStr.add("681C0105000000CD9612345678031101A50102048F03A600123456787A8B16");
+        sendStr.add("681C0105000000CD9612345678031101A50102045703B20012345678756516");
+        sendStr.add("681C0105000000CD9612345678031101A50102042003BC0012345678328916");
+        sendStr.add("681C0105000000CD9612345678031101A5010203E803C30012345678128016");
+        sendStr.add("681C0105000000CD9612345678031101A5010203B003C9001234567816B016");
+        sendStr.add("681C0105000000CD9612345678031101A50102037903CC0012345678DADF16");
+        sendStr.add("681C0105000000CD9612345678031101A501020877082F001234567884F016");
+
+    }
+
+    public static boolean wait10Seconds() {
+        try {
+            Thread.sleep(6000);
+        } catch (InterruptedException e) {
+        }
+        return true;
+    }
+
+    public static void main(String[] args) {
+        try {
+            NRJavaSerialService nRJavaSerialService = new NRJavaSerialService();
+            nRJavaSerialService.connect("/dev/tty.usbserial-14130");// /dev/ttyUSB0
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void connect(String port) {
+
+
+        NRSerialPort serialPort = new NRSerialPort(port, 9600);
+        boolean b = serialPort.connect();
+        logger.info("serialPort------" + b);
+        DataInputStream inStream = new DataInputStream(serialPort.getInputStream());
+        DataOutputStream outStream = new DataOutputStream(serialPort.getOutputStream());
+
+        new Thread(new SerialWriter(outStream), "SerialWriter").start();
+        new Thread(new SerialReader(inStream), "SerialReader").start();
+    }
+
+    public static class SerialReader implements Runnable {
+        private final DataInputStream inStream;
+
+        public SerialReader(DataInputStream inStream) {
+            this.inStream = inStream;
+        }
+
+
+        public void run() {
+            try {
+                while (!Thread.interrupted()) {// read all bytes
+                    int byteLen = inStream.available();
+                    if (byteLen > 0) {
+                        byte[] buffer = new byte[byteLen];
+                        inStream.read(buffer);
+
+                        String str = StrSplicingAssistant.bytesToHexString(buffer);
+                        if (str.endsWith("16")) {
+
+                            //心跳 设备在线
+                            if (str.equals("68140186000000E55A1234567803510112345678B1E216")) {
+                                isHeartbeat = true;
+                            } else if (str.startsWith("68220185000000E088")) {
+                                isReceive = true;
+                                //异常 测距失败
+                                if (!str.contains("EEEEEEEE")) {
+                                    logger.info("EEEEEEEE------" + str);
+                                }
+
+                                // TODO: 2021/12/28 打点有值，但需要crc验证。
+
+                                //  等待10秒
+                                String deviceid = str.substring(18, 26);//截取设备id
+                                String anglez = str.substring(38, 42);//截取角度
+                                String angley = str.substring(42, 46);//截取角度
+                                String anglezy = str.substring(38, 46);//角度
+                                String distance = str.substring(46, 54);//截取距离
+                                logger.info("receive = " + anglezy + " | " + distance);
+
+                            } else if (wait10Seconds()) {
+                                isReceive = true;
+                                logger.info("wait10Seconds = " + str);
+
+                            }
+                        }
+                    }
+                    Thread.sleep(600);
+                }
+
+            } catch (IOException e) {
+                e.printStackTrace();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public static class SerialWriter implements Runnable {
+        private final DataOutputStream outStream;
+        boolean onlyOnce = true;
+
+        public SerialWriter(DataOutputStream outStream) {
+            this.outStream = outStream;
+        }
+
+        public void run() {
+            try {
+                while (!Thread.interrupted()) {
+                    if (isHeartbeat && onlyOnce) {
+                        outStream.write(StrSplicingAssistant.hexStrToByteArrs("681C0105000000CD9612345678031101A5010205DC05DC00123456785FA816"));
+                        onlyOnce = false;
+                        logger.info("init = 1500,1500:05DC05DC");
+                    }
+                    if (isHeartbeat && isReceive) {
+                        if (sendStr.size() > 0) {
+                            Iterator iterator = sendStr.iterator();
+                            if (iterator.hasNext()) {
+                                String s = (String) iterator.next();
+                                outStream.write(StrSplicingAssistant.hexStrToByteArrs(s));
+                                iterator.remove();
+                                isReceive = false;
+                                logger.info(sendStr.size() + "_send_str = " + s.substring(38, 46));
+
+                            }
+                        }
+                    }
+                    Thread.sleep(600);
+                }
+
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}

src/main/java/com/sjls/nstthh/util/AlgAlgorithm.java

@@ -0,0 +1,113 @@
+package com.sjls.nstthh.util;
+
+
+public class AlgAlgorithm {
+
+    /**
+     * 打点
+     *
+     * @param
+     */
+
+    public static String getAveragePosition() {
+
+
+        StringBuffer sb = new StringBuffer();
+
+        //圆筒仓的直径
+        double d = 12;
+        //AC 是设备到地面的高
+        double AC = 35;
+        double x1 = 0;
+        double y1 = 0;
+        //打出来三角形的底边AB 实际是平面上点的斜边
+        double AB = 0; //理想状态
+        double x = 0;
+        double y = 0;
+        double BC = 0;
+        double vertical_angle = 0;//垂直的角度
+        double level_angle = 0;//水平的角度
+        double vertical_step = 0;//垂直的步长
+        double level_step = 0;//水平的步长
+
+        //根据直径判断半径是整数还是非整数 如果是非整数 则向下取整
+        double r = Math.floor(d / 2);  //最大的半径 即一共有多少个圆圈
+
+        //一共有多少个圆圈
+        int circleNumber = (int) r;
+
+        for (int i = 1; i <= circleNumber; i++) {
+            //每一个圆一共有多少个的点   此时的半径长就是i
+            int pointCount = (int) ((2 * Math.PI * i) / 1.57);
+
+            for (int j = 0; j < pointCount; j++) {
+
+                /**
+                 * 以其他点为圆心的圆  r是i degrees是以圆心为中心转动的角度 其坐标x1、y1则是
+                 */
+                double degrees = (360 / pointCount) * j;
+                //System.out.println(degrees+"度数");
+                double radians = Math.toRadians(degrees);//转化为弧度
+                String strx = String.format("%.2f%n", Math.cos(radians) * i);//计算横坐标的值
+                x1 = new Double(strx);
+                String stry = String.format("%.2f%n", Math.sin(radians) * i);//计算纵坐标的值
+                y1 = new Double(stry);
+
+                /**
+                 * 以设备为中心，把圆上的点分为上下两半，
+                 * 新的圆 是旧的圆向左平移了(d/2-i)+i 个长度 得到的
+                 * (设备在新的圆的最左边上，设备是坐标系的原点)
+                 * 所以 横坐标加上这个长度  纵坐标不变
+                 */
+
+                //纵坐标 无论是处于上半部分还是下半部分 其纵坐标是不变的
+                x = x1 + (d / 2 - i) + i;
+                y = y1;
+                //System.out.print("["+x+","+y+"]"+",");
+                //底面三角形的斜边
+                AB = Math.sqrt(x * x + y * y);
+                //垂直三角形的斜边
+                BC = Math.sqrt(AB * AB + AC * AC);
+                if (x == 0 && y == 0) {//圆 点
+                    level_angle = 0;
+                    vertical_angle = 0;
+
+                } else if (y < 0) {//反向转
+                    level_angle = -Math.toDegrees(Math.acos(Math.abs(y) / AB));
+                    vertical_angle = -(90 - Math.toDegrees(Math.acos(AC / BC)));
+
+                } else {//正向转
+                    level_angle = Math.toDegrees(Math.acos(y / AB));
+                    vertical_angle = 90 - Math.toDegrees(Math.acos(AC / BC));
+
+                }
+                //转为步长
+                level_step = 1500 + level_angle / 0.135;
+                vertical_step = 1500 + vertical_angle / 0.135;
+
+                sb.append(Math.round(level_step));
+                sb.append(",");
+                sb.append(Math.round(vertical_step));
+                sb.append(";");
+                // sb.append("\n");
+
+            }
+        }
+
+        /**
+         * 追加一个圆筒仓中心的点，其坐标是(d/2,0) 水平转动90度 步长为2167
+         */
+        AB = d / 2;//垂直三角形的底边
+        BC = Math.sqrt(AB * AB + AC * AC);//垂直三角形的斜边
+        vertical_angle = 90 - Math.toDegrees(Math.acos(AC / BC));
+        vertical_step = 1500 + vertical_angle / 0.135;
+        sb.append(2167);
+        sb.append(",");
+        sb.append(Math.round(vertical_step));
+        // sb.append("\n");
+        //System.out.println(Math.round(level_step)+","+Math.round(vertical_step)+"");
+        //System.out.println(sb);
+
+        return sb.toString();
+    }
+}

src/main/java/com/sjls/nstthh/util/LaserRangingServer.java

@@ -0,0 +1,78 @@
+package com.sjls.nstthh.util;
+
+import cn.hutool.core.io.FileUtil;
+import cn.hutool.core.io.file.FileReader;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.List;
+
+/**
+ * node java
+ */
+public class LaserRangingServer implements Runnable {
+
+    private static final int PORT = 8089;
+    static String start = "68 07 FF FF FF FF FF E6 F1 16";
+    static String end = "68 07 00 00 00 00 00 F3 71 16";
+    private final Socket socket;
+
+    LaserRangingServer(Socket socket) {
+        this.socket = socket;
+    }
+
+    public static void main(String[] args) throws IOException {
+        ServerSocket serverSocket = new ServerSocket(PORT);
+        while (true) {
+            Socket socket = serverSocket.accept();
+            new Thread(new LaserRangingServer(socket)).start();
+        }
+    }
+
+    @Override
+    public void run() {
+        try {
+            System.out.println("new:" + socket.getInetAddress() + ":" + socket.getPort());
+
+            OutputStream out = socket.getOutputStream();
+            while (true) {
+                if (FileUtil.exist("send_data.dat")) {
+                    FileReader fileReader = new FileReader("send_data.dat");
+                    List<String> str = fileReader.readLines();
+                    if (!str.isEmpty()) {
+                        out.write(StrSplicingAssistant.hexStrToByteArrs(start));
+                        System.out.println(start + "-----------strar");
+                        for (String s : str) {
+                            Thread.sleep(3600);
+                            out.write(StrSplicingAssistant.hexStrToByteArrs(s));
+                            System.out.println(s);
+                        }
+                        Thread.sleep(1200);
+                        out.write(StrSplicingAssistant.hexStrToByteArrs(end));
+                        System.out.println(end + "-----------end");
+                        //out.flush();
+                        FileUtil.del("send_data.dat");
+                    }
+                    Thread.sleep(3600);
+                    //out.close();
+                }
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } finally {
+            if (socket != null) {
+                try {
+                    socket.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+
+        }
+
+    }
+}

src/main/java/com/sjls/nstthh/util/StrSplicingAssistant.java

@@ -0,0 +1,203 @@
+package com.sjls.nstthh.util;
+
+import java.io.ByteArrayOutputStream;
+
+public class StrSplicingAssistant {
+
+    private static final String hexString = "0123456789ABCDEF";
+    /**
+     * 步长率
+     */
+    static double Step = 0.135;
+
+    /**
+     * 计算CRC16校验码
+     *
+     * @param bytes
+     * @return
+     */
+    public static String getCRC(byte[] bytes) {
+        int CRC = 0x0000ffff;
+        int POLYNOMIAL = 0x0000a001;
+
+        int i, j;
+        for (i = 0; i < bytes.length; i++) {
+            CRC ^= ((int) bytes[i] & 0x000000ff);
+            for (j = 0; j < 8; j++) {
+                if ((CRC & 0x00000001) != 0) {
+                    CRC >>= 1;
+                    CRC ^= POLYNOMIAL;
+                } else {
+                    CRC >>= 1;
+                }
+            }
+        }
+        return Integer.toHexString(CRC);
+    }
+
+    /**
+     * 逆序校验
+     *
+     * @param dataHexStr
+     * @return
+     */
+    public static String CRC16Right(String dataHexStr) {
+        //字符串类型的16进制字符串转换为字节数组
+        byte[] data = hexStrToByteArrs(dataHexStr);
+        //初始化寄存器 我们用数据的低八位进行处理,已经可以不用限制寄存器的个数了
+        //我测试了int long 都能达到预期的效果 但是short 反而数据错误 没想明白为什么。
+        int crci = 0xffff;
+        int i, j;
+        for (j = 0; j < data.length; j++) {
+            //此处&0x00ff的目的是为了将数据放入寄存器的低8位并与寄存器异或
+            crci ^= data[j] & 0x00ff;
+            for (i = 0; i < 8; i++) {
+                //判断即将右移的是不是1 如果是1则与多项式进行异或
+                if ((crci & 0X0001) == 0X0001) {
+                    crci >>= 1;
+                    //将数据与约定的多项式做（模二除/异或）  数据流向变了此处的异或值实际是8005的逆序反转a001
+                    crci ^= 0xa001;
+                } else {
+                    crci >>= 1;
+                }
+            }
+        }
+        //结果值与0x0000异或 其实值不会改变，不异或对结果没有影响
+        String res = Long.toHexString(crci ^ 0x0000);
+        if (res.length() < 4) {
+            res = "0" + res;
+        }
+
+        return res;
+    }
+
+    public static String strEncode10_16(String str10) {
+        byte[] bytes = str10.getBytes();
+        StringBuilder sb = new StringBuilder(bytes.length * 2);
+
+        for (int i = 0; i < bytes.length; i++) {
+            sb.append(hexString.charAt((bytes[i] & 0xf0) >> 4));
+            sb.append(hexString.charAt((bytes[i] & 0x0f) >> 0));
+        }
+        return sb.toString();
+    }
+
+    public static String strDecode16_10(String str16) {
+
+        ByteArrayOutputStream baos = new ByteArrayOutputStream(str16.length() / 2);
+
+        for (int i = 0; i < str16.length(); i += 2)
+            baos.write((hexString.indexOf(str16.charAt(i)) << 4 | hexString.indexOf(str16.charAt(i + 1))));
+        return baos.toString();
+    }
+
+    /**
+     * 将十六进制的字符串转换成字节数组
+     *
+     * @param hexString
+     * @return byte[]
+     */
+    public static byte[] hexStrToByteArrs(String hexString) {
+        hexString = hexString.replaceAll(" ", "");
+        int len = hexString.length();
+        int index = 0;
+
+        byte[] bytes = new byte[len / 2];
+
+        while (index < len) {
+            String sub = hexString.substring(index, index + 2);
+            bytes[index / 2] = (byte) Integer.parseInt(sub, 16);
+            index += 2;
+        }
+
+        return bytes;
+    }
+
+    public static String byteToHex(byte b) {
+        String hex = Integer.toHexString(b & 0xFF);
+        if (hex.length() < 2) {
+            hex = "0" + hex;
+        }
+        return hex;
+    }
+
+
+    /**
+     * 数组转换成十六进制字符串
+     *
+     * @param bArray
+     * @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();
+    }
+
+    /**
+     * 10进制 转 16进制
+     *
+     * @param i
+     * @return 16_i
+     */
+    public static String hex10To16(long i) {
+        return String.format("%04X", i);
+    }
+
+    /**
+     * 角度转步长
+     * 500？2500？ 1500
+     *
+     * @param angle
+     * @return int
+     */
+    public static long angleTransformationStep(double angle) {
+        return Math.round(angle / Step);
+    }
+
+
+    /**
+     * 字符串 每隔2位加空格，最后也有空格
+     * 如 E803E800 转 E8 03 E8 00
+     *
+     * @param str
+     * @return String
+     */
+    public static String spaceEveryTwoStrings(String str) {
+        return str.replaceAll("(.{2})", "$1 ");
+    }
+
+
+    /**
+     * 高低位转换 大写
+     * 如“1A2B”转“2B1A”。
+     *
+     * @param hex
+     * @return String
+     */
+    public static String displacementHighLow(String hex) {
+        char[] charArray = hex.toCharArray();
+        int length = charArray.length;
+        int times = length / 2;
+        for (int c1i = 0; c1i < times; c1i += 2) {
+            int c2i = c1i + 1;
+            char c1 = charArray[c1i];
+            char c2 = charArray[c2i];
+            int c3i = length - c1i - 2;
+            int c4i = length - c1i - 1;
+            charArray[c1i] = charArray[c3i];
+            charArray[c2i] = charArray[c4i];
+            charArray[c3i] = c1;
+            charArray[c4i] = c2;
+        }
+        return new String(charArray).toUpperCase();
+
+    }
+}

src/main/resources/application.yml

@@ -0,0 +1,26 @@
+server:
+  port: 8080
+management:
+  endpoint:
+    shutdown:
+      enabled: true
+  endpoints:
+    web:
+      exposure:
+        include: shutdown
+# DataSource Config
+spring:
+  datasource:
+    driver-class-name: org.h2.Driver
+    url: jdbc:h2:~/nstthh;AUTO_SERVER=TRUE
+    username: sa
+    password: 123456
+
+  jpa:
+    show-sql: true
+    hibernate:
+      ddl-auto: update
+  h2:
+    console:
+      path: /h2-console
+      enabled: true

src/main/resources/static/data.js

@@ -0,0 +1,387 @@
+const fs = require('fs');
+const readline = require('readline');
+const liner = readline.createInterface({
+    input: fs.createReadStream("/home/pi/config.txt")
+});
+var lineIndex = 0;
+var line;
+var ServerIP;
+var ServerPort;
+var ComName;
+var HttpUrl;
+var chunk;
+
+liner.on('line', function (line) { //事件监听
+
+    if (lineIndex === 0)
+        ServerIP = line;
+    else if (lineIndex === 1)
+        ServerPort = line;
+    else if (lineIndex === 2)
+        ComName = line;
+    else if (lineIndex === 3) {
+        HttpUrl = line;
+        console.log('ServerIP:' + ServerIP + "," + "ServerPort:" + ServerPort + "," + "ComName:" + ComName + "," + "HttpUrl:" + HttpUrl);
+    }
+
+    lineIndex = lineIndex + 1;
+})
+var SocketDataIndex = 0;
+var SocketDataList = [];
+var isSocketStarted = false;//socket开始接受数据
+var isSocketEnded = false;//socket结束接受数据
+var isComStart = false;//串口是否有回复
+var net = require('net');
+var socket;
+var isConnected = false;
+
+setInterval(function () {
+    if (isConnected == false) {
+        TCPFunction();
+    }
+}, 3000);//定时3秒检查tcp连接状态
+
+
+const iconv = require("iconv-lite");
+const encodeconvert = require("encoding");
+
+function TCPFunction() {
+
+    socket = new net.Socket();
+    socket.setEncoding('hex');
+
+    socket.connect(ServerPort, ServerIP, function () {
+        socket.write('hello');
+        isConnected = true;
+    });
+
+    socket.on('data', function (data) {
+        var data1 = data.slice(0, data.legth);
+
+        console.log("value:" + data1);
+        if (isSocketStarted == false) {
+            if (data1 == "6807ffffffffffe6f116") {//开始命令
+
+                isSuccessHttp = false;
+                StartHttpNum = 0;
+                clearInterval(IntervalHttp);//释放http的定时器
+                isSocketEnded = false;
+                isComStart = false;
+
+                post_data = [];
+                isSocketStarted = true;
+                SocketDataIndex = 0;
+                SocketDataList = [];
+                fs.writeFile('/home/pi/DataTest/data1.txt', "", (err, data) => {
+                    if (err) throw err;
+                });
+                fs.writeFile('/home/pi/DataTest/data2.txt', "", (err, data) => {
+                    if (err) throw err;
+                });
+            } else {
+                if ((data1 != 0xff) && (data1 != "68140186000000e55a12345678b1e216")) {
+                    var bt = Hexstring2btye(data1);
+                    serialPort.write(bt, function (err, results) {
+                        //console.log('err'+err);
+                        //console.log('results'+results);
+                    });
+                }
+            }
+        } else {
+            if (data1 == "68070000000000f37116") {//结束命令
+                isSocketEnded = true;
+                isSocketStarted = false;
+                isComStart = true;
+                console.log('SocketDataList:' + SocketDataList[0]);
+                var bt = Hexstring2btye(SocketDataList[0]);
+                serialPort.write(bt, function (err, results) {
+                    //console.log('err'+err);
+                    //console.log('results'+results);
+                    /*
+                    var bt = Hexstring2btye(tst);
+                    console.log(bt);
+                    var st = Bytes2HexString(bt);
+                    console.log(st);
+                    */
+                });
+                SocketDataIndex = 0;
+            } else {
+                if (isSocketEnded == false) {
+                    SocketDataList[SocketDataIndex] = data1;
+                    SocketDataIndex = SocketDataIndex + 1;
+                    fs.appendFile('/home/pi/DataTest/data1.txt', data1 + '\r\n', (err, data) => {
+                        if (err) throw err;
+                    });
+                }
+            }
+        }
+    });
+
+    socket.on('end', function () {
+        console.log("disconnect");
+        isConnected = false;
+        socket.destroy();
+    });
+
+    socket.on('error', function (err) {
+        isConnected = false;
+        console.log(err);
+        socket.destroy();
+    });
+
+}
+
+var serialPort = require('serialport');
+setTimeout(function () {
+
+    //Opening a Port
+    serialPort = new serialPort(ComName, {
+        //波特率，可在设备管理器中对应端口的属性中查看
+        baudRate: 9600,
+        autoOpen: false
+    })
+    //连接串口后进行写入指令操作
+    serialPort.open(function (err) {
+        console.log('IsOpen:', serialPort.isOpen)
+        //		serialPort.write("123",function(err,results){
+        //console.log('err'+err);
+        //console.log('results'+results);
+        //});
+
+    })
+
+    setInterval(function () {
+        var btm;
+        var i;
+        if (isComStart == true) {
+            RevComDataCount = RevComDataCount + 1;
+            if (RevComDataCount >= 10) {
+                RevComDataCount = 0;
+                //打印模拟数据
+                console.log('time out!!!!!!!!!!!!!!!!!');
+                var chunkc = ['68', '22', '01', '85', '00', '00', '00', 'e0', '88', '12', '34', '56', '78', '03', '11', '01', 'b5', '01', '02', 'ff', 'ff', 'ff', 'ff', 'ff', 'ff', 'ff', 'ff', '00', 'ff', 'd8', '12', '34', '56', '78', 'd8', '69', '16'];
+                btm = chunkc;
+                console.log('chaoshi:' + btm.length + "    " + btm);
+                analysisData(btm);
+            }
+        }//超时反馈假数据
+    }, 1000);//定时1秒检查串口是否接受过数据
+
+    var isRevComData = false;
+    var RevComDataCount = 0;
+
+    var chunk_buf;
+    var flag_com;
+    var mlenbuf;
+    const InterByteTimeout = require('@serialport/parser-inter-byte-timeout');
+    const parser = serialPort.pipe(new InterByteTimeout({interval: 25})); // 2000毫秒未接到数据触发
+    parser.on('data', chunk => {
+        console.log('data received: ' + chunk);
+        console.log('data received: ' + chunk.length + "    " + chunk.toString('hex'));
+        if (isComStart == true) {
+            analysisData(chunk);
+        }
+
+    });
+
+
+    function analysisData(chunk) {
+        if (chunk.length < 37) {
+            if (chunk[1] == 0x22) {
+                chunk_buf = chunk;
+                flag_com = 2;
+                mlenbuf = chunk.length;
+                //console.log('mlenbuf:' + mlenbuf);////
+            } else if (((chunk.length + mlenbuf) == 37) && (flag_com == 2)) {
+                chunk = chunk_buf.toString('hex') + chunk.toString('hex');
+                flag_com = 3;
+                //console.log('3333' + chunk);
+            } else {
+                chunk = "";
+            }
+            RevComDataCount = 0;//有数据定时器计数清零
+        }
+        if ((chunk.length == 37) || (flag_com == 3)) {
+
+            RevComDataCount = 0;//有数据定时器计数清零
+            fs.appendFile('/home/pi/DataTest/data2.txt', chunk.toString('hex') + '\r\n', (err, msg) => {
+                if (err) throw err;
+            });
+
+            var comData = chunk.toString('hex');
+            var jsonArr = {};
+            if (comData.length == 110) {
+                var idd;
+                var comDatabuf;
+                for (idd = 0; idd < 110; idd++) {
+                    if (comData[idd] == ',') {
+                    } else {
+                        comDatabuf += comData[idd];
+                    }
+                }
+                comData = comDatabuf.substring(9, 83);
+            }
+            post_data.deviceid = comData.substring(18, 26);//截取设备id
+            jsonArr.anglez = comData.substring(38, 42);//截取角度
+            jsonArr.angley = comData.substring(42, 46);//截取角度
+            jsonArr.distance = comData.substring(46, 54);//截取距离
+
+            post_data.push(jsonArr);//json合并
+
+            if (isComStart == true) {
+
+                console.log(post_data);
+
+                SocketDataIndex = SocketDataIndex + 1;
+                if (SocketDataIndex >= SocketDataList.length) {
+                    isComStart = false;
+                    console.log('startHttp');
+
+                    HttpFun();
+                    IntervalHttp = setInterval(HttpFun, 30000);//间隔30秒发送http
+
+                } else {
+                    var bt = Hexstring2btye(SocketDataList[SocketDataIndex]);
+                    serialPort.write(bt, function (err, results) {
+                        //console.log('err'+err);
+                        //console.log('results'+results);
+                    });
+
+                }
+
+            }
+            console.log('SocketDataList:' + SocketDataList.length + "," + SocketDataIndex);
+            flag_com = 0;
+            mlenbuf = 0;
+        } else {
+            chunk = "";
+        }
+    }
+
+    //指令监听
+    /*serialPort.on('data', function (data) {
+        console.log('data received: ' + data.toString('hex'));
+        fs.appendFile('/home/pi/DataTest/data2.txt', data.toString('hex') + '\r\n', (err, data) => {
+            if (err) throw err;
+        });
+        var comData = data.toString('hex');
+        var jsonArr = {};
+        post_data.deviceid = comData.substring(18, 26);//截取设备id
+        jsonArr.angle = comData.substring(38, 41);//截取角度
+        jsonArr.angle2 = comData.substring(42, 45);//截取角度
+        jsonArr.distance = comData.substring(46, 54);//截取距离
+
+        post_data.push(jsonArr);//json合并
+
+
+
+        if (isComStart == true) {
+
+            console.log(post_data);
+
+            SocketDataIndex = SocketDataIndex + 1;
+            if (SocketDataIndex >= SocketDataList.length) {
+                isComStart = false;
+                console.log('startHttp');
+
+                HttpFun();
+                IntervalHttp = setInterval(HttpFun, 30000);//间隔30秒发送http
+
+            }
+            else {
+                var bt = Hexstring2btye(SocketDataList[SocketDataIndex]);
+                serialPort.write(bt, function (err, results) {
+                    //console.log('err'+err);
+                    //console.log('results'+results);
+                });
+                time.sleep(0.1);
+            }
+
+        }
+        console.log('SocketDataList:' + SocketDataList.length + "," + SocketDataIndex);
+
+    })*/
+    //错误监听
+    serialPort.on('error', function (error) {
+        console.log('error: ' + error)
+    })
+
+}, 1000);
+
+var StartHttpNum = 0;//发送http的次数
+var IntervalHttp;//定时器，发送htto
+var isSuccessHttp = false;//http是否成功响应
+var post_data = [];//json数组
+function HttpFun() {
+    if (isSuccessHttp == false) {
+        console.log('startHttp');
+        StartHttpNum = StartHttpNum + 1;
+        if (StartHttpNum > 10) {
+            StartHttpNum = 0;
+            clearInterval(IntervalHttp);//释放http的定时器
+            isSocketStarted = false;
+            isSocketEnded = false;
+            isComStart = false;
+        }
+        var request = require("request");
+        request({
+            url: HttpUrl,
+            method: "GET",
+            json: true,
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(post_data)
+        }, function (error, response, body) {
+            if (!error && response.statusCode == 200) {
+                console.log(body);
+                isSuccessHttp = true;
+                clearInterval(IntervalHttp);
+
+                isSocketStarted = false;
+                isSocketEnded = false;
+                isComStart = false;
+            }
+        });
+    }
+
+}
+
+const Hexstring2btye = (str) => {
+    let pos = 0;
+    let len = str.length;
+    if (len % 2 != 0) {
+        return null;
+    }
+    len /= 2;
+    let hexA = [];
+    for (let i = 0; i < len; i++) {
+        let s = str.substr(pos, 2);
+        let v = parseInt(s, 16);
+        hexA.push(v);
+        pos += 2;
+    }
+    return hexA;
+}
+
+
+const Bytes2HexString = (b) => {
+    let hexs = "";
+    for (let i = 0; i < b.length; i++) {
+        let hex = b[i].toString(16);
+        if (hex.length == 1) {
+            hex = '0' + hex;
+        }
+        hexs += hex.toUpperCase();
+    }
+    return hexs;
+}
+
+
+/*
+var tst = "ba3697dd768150d1e2162dd9ae643694";
+
+var bt = Hexstring2btye(tst);
+console.log(bt);
+var st = Bytes2HexString(bt);
+console.log(st);*/

src/test/java/com/sjls/nstthh/NstthhApplicationTests.java

@@ -0,0 +1,13 @@
+package com.sjls.nstthh;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class NstthhApplicationTests {
+
+    @Test
+    void contextLoads() {
+    }
+
+}

src/test/java/com/sjls/nstthh/RepositoryTest.java

@@ -0,0 +1,36 @@
+package com.sjls.nstthh;
+
+
+import com.sjls.nstthh.repository.CommunicationDataRepository;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+@SpringBootTest
+@RunWith(SpringRunner.class)
+public class RepositoryTest {
+
+    @Autowired
+    private CommunicationDataRepository userRepository;
+
+    @Test
+    public void addUser() {
+//        CommunicationData user = new CommunicationData();
+//        //user.setId(1L);
+//        user.setReceive(true);
+//        user.setSend(true);
+//        user.setSendData("681C0105000000CD9612345678031101A50102029B029B001234567845F916");
+//        user.setReceiveData("68220185000000E08812345678031101B50102029B029B0000098900FF8312341234567803510112345678B1E21600000000");
+//        userRepository.save(user);
+//
+//
+//        SendData sendData = new SendData();
+//        //user.setId(1L);
+//        sendData.setSendStr("681C0105000000CD9612345678031101A50102029B029B001234567845F916");
+//        //sendData.setGroupVal();
+//        sendData.setSendKey("029B029B");
+//        userRepository.save(user);
+    }
+}

src/test/java/com/sjls/nstthh/TestNstthh.java

@@ -0,0 +1,105 @@
+package com.sjls.nstthh;
+
+import cn.hutool.core.util.StrUtil;
+import com.sjls.nstthh.util.AlgAlgorithm;
+import com.sjls.nstthh.util.StrSplicingAssistant;
+
+import java.io.IOException;
+
+public class TestNstthh {
+
+    static String start = "68 07 FF FF FF FF FF E6 F1 16";
+    static String end = "68 07 00 00 00 00 00 F3 71 16";
+
+    public static void main(String[] args) throws IOException {
+
+        String str = AlgAlgorithm.getAveragePosition();
+        String[] strArr_z_y = str.split(";");
+
+        for (int i = 0; i < strArr_z_y.length; i++) {
+
+            String[] strArr = strArr_z_y[i].split(",");
+
+
+            //System.out.println(Long.valueOf(strArr[0]));  System.out.println(Long.valueOf(strArr[1]));
+            String str10 = send16strUseCom(Long.valueOf(strArr[0]), Long.valueOf(strArr[1]));
+            System.out.println("sendStr.add(\"" + str10 + "\");");
+        }
+
+
+    }
+
+    public static String send16strUseCom(long z_val, long y_val) {
+
+        // 第一个{}为 ：z，y 角度转为步长 16进制 每隔两位字符串串加空格
+        // 第二个{}为 ：sendStr_1_tmp串 crc验证后
+        String sendStr_0_tmp = "681C0105000000CD96";
+        String sendStr_1_tmp = "12345678031101A50102{}0012345678";
+        String sendStr_2_tmp = "{}16";
+
+
+//        String z = StrSplicingAssistant.hex10To16(StrSplicingAssistant.angleTransformationStep(z_val));
+//        String y = StrSplicingAssistant.hex10To16(StrSplicingAssistant.angleTransformationStep(y_val));
+        String z = StrSplicingAssistant.hex10To16(z_val);
+        String y = StrSplicingAssistant.hex10To16(y_val);
+        //16进制zy 替换 sendStr_1_tmp{}
+        String sendStr_1_v = StrUtil.format(sendStr_1_tmp, z + y);
+        //sendStr_1_v比特流CRC验证逆序并高低位置换后加空格格式化 替换 sendStr_2_tmp{}
+        String sendStr_2_v = StrUtil.format(sendStr_2_tmp, StrSplicingAssistant.displacementHighLow(StrSplicingAssistant.CRC16Right(sendStr_1_v)));
+
+        String sendstr_ = sendStr_0_tmp + sendStr_1_v + sendStr_2_v;
+        // System.out.print(sendstr_);
+
+        return sendstr_;
+    }
+
+    public static String send16str(double z_val, double y_val) {
+
+        // 第一个{}为 ：z，y 角度转为步长 16进制 每隔两位字符串串加空格
+        // 第二个{}为 ：sendStr_1_tmp串 crc验证后
+        String sendStr_0_tmp = "68 1C 01 05 00 00 00 CD 96 ";
+        String sendStr_1_tmp = "12 34 56 78 03 11 01 A5 01 02 {}00 12 34 56 78 ";
+        String sendStr_2_tmp = "{}16";
+
+
+        String z = StrSplicingAssistant.hex10To16(StrSplicingAssistant.angleTransformationStep(z_val));
+        String y = StrSplicingAssistant.hex10To16(StrSplicingAssistant.angleTransformationStep(y_val));
+
+        //16进制zy 替换 sendStr_1_tmp{}
+        String sendStr_1_v = StrUtil.format(sendStr_1_tmp, StrSplicingAssistant.spaceEveryTwoStrings(z + y));
+        //sendStr_1_v比特流CRC验证逆序并高低位置换后加空格格式化 替换 sendStr_2_tmp{}
+        String sendStr_2_v = StrUtil.format(sendStr_2_tmp, StrSplicingAssistant.spaceEveryTwoStrings(StrSplicingAssistant.displacementHighLow(StrSplicingAssistant.CRC16Right(sendStr_1_v))));
+
+        String sendstr_ = sendStr_0_tmp + sendStr_1_v + sendStr_2_v;
+        // System.out.print(sendstr_);
+
+        return sendstr_;
+    }
+
+    /**
+     * z,y;z,y;
+     *
+     * @param zyStr
+     * @return
+     */
+    public static String[] zyStrToSend16str(String zyStr) {
+
+
+        String[] strArr_zy = zyStr.split("\\;");
+        String[] strArr_zy_n = new String[strArr_zy.length];
+        for (int i = 0; i < strArr_zy.length; i++) {
+
+            String[] strArr_z_y = strArr_zy[i].split("\\,");
+
+            String z = strArr_z_y[0];
+            String y = strArr_z_y[1];
+
+            // strArr_zy_n[i] = send16strUseCom(Double.valueOf(z), Double.valueOf(y));
+            //strArr_zy_n[i] = send16str(Double.valueOf(z), Double.valueOf(y));
+
+        }
+
+        return strArr_zy_n;
+    }
+
+}