根据新的多参数传输协议，修改解析规则

riku

2020-07-15 25d0f31f22f77a914a50bbc088902e00e28c4889

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
package com.flightfeather.uav.socket.decoder.impl
 
import com.flightfeather.uav.socket.bean.AirData
import com.flightfeather.uav.socket.bean.AirDataPackage
import com.flightfeather.uav.socket.bean.AirTypeData
import com.flightfeather.uav.socket.decoder.DataUnitDecoder
import com.flightfeather.uav.socket.eunm.FactorType
import org.slf4j.LoggerFactory
 
/**
 * @author riku
 * Date: 2019/9/15
 */
class DataUnitDecoderImpl : DataUnitDecoder {
 
    private val logger = LoggerFactory.getLogger(javaClass.name)
 
    private val types = mutableListOf<AirTypeData>()
 
    override fun getAirConfirmData(b: List<String>): List<AirTypeData> {
        val resultList = mutableListOf<AirTypeData>()
        b.forEach {
            FactorType.getByIndex(it.toInt(16))?.let { f->
                resultList.add(AirTypeData(f))
            }
        }
        types.clear()
        types.addAll(resultList)
 
        return resultList
    }
 
    override fun getAirData(b: List<String>): List<AirData> {
        val resultList = mutableListOf<AirData>()
 
        var i = 0
        types.forEach {
            if (i > b.size - it.factorType.byteLength) {
                return@forEach
            }
            when (it.factorType.byteLength) {
                AirDataPackage.FACTOR_BIT_LENGTH_2 -> {
                    val a1 = "${b[i]}${b[i + 1]}".toInt(16)
                    var b1 = b[i + 2].toInt(16).toDouble()
                    while (b1 >= 1) {
                        b1 /= 10
                    }
                    val data1 = a1 + b1
 
                    resultList.add(AirData().apply {
                        factorId = it.factorType.value?.toString()
                        factorName = it.factorType.des
                        factorData = data1
                    })
                }
                AirDataPackage.FACTOR_BIT_LENGTH_1 -> {
                    //数据实际值（3位字节表示）
                    val a1 = "${b[i]}${b[i + 1]}".toInt(16)
                    var b1 = b[i + 2].toInt(16).toDouble()
                    while (b1 >= 1) {
                        b1 /= 10
                    }
                    val data1 = a1 + b1
 
                    //数据物理量（3位字节表示）
                    val a2 = "${b[i]}${b[i + 1]}".toInt(16)
                    var b2 = b[i + 2].toInt(16).toDouble()
                    while (b2 >= 1) {
                        b2 /= 10
                    }
                    val data2 = a2 + b2
 
                    resultList.add(AirData().apply {
                        factorId = it.factorType.value?.toString()
                        factorName = it.factorType.des
                        factorData = data1
                        physicalQuantity = data2
                    })
                }
            }
            i += it.factorType.byteLength
        }
 
        return resultList
    }
}