Merge remote-tracking branch 'obdserver2/master'

riku

2021-03-01 09f411e381f885619b32e05fc89cad26bb20824d

 src/main/kotlin/com/flightfeather/uav/socket/MessageManager.kt

@@ -2,14 +2,10 @@

import com.flightfeather.uav.common.utils.FileUtil
import com.flightfeather.uav.repository.*
import com.flightfeather.uav.socket.bean.EngineDataStream
import com.flightfeather.uav.socket.bean.ObdInfo
import com.flightfeather.uav.socket.bean.ObdPackageData
import com.flightfeather.uav.socket.bean.SupplementDataStream
import com.flightfeather.uav.socket.decoder.VehicleDataDecoder
import com.flightfeather.uav.socket.bean.*
import com.flightfeather.uav.socket.decoder.AirDataDecoder
import com.flightfeather.uav.socket.decoder.impl.DataPackageDecoderImpl
import com.flightfeather.uav.socket.eunm.ObdCommandUnit
import io.netty.buffer.Unpooled
import com.flightfeather.uav.socket.eunm.AirCommandUnit
import io.netty.channel.ChannelHandlerContext
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Component
@@ -28,53 +24,34 @@

    companion object{
        private lateinit var instance: MessageManager

        private const val TAG = "UAV"
    }

    @Autowired
    lateinit var obdDataRepository: ObdDataRepository
    @Autowired
    lateinit var originDataRepository: OriginDataRepository
    @Autowired
    lateinit var obdInfoRepository: ObdInfoRepository
    @Autowired
    lateinit var dataStreamRepository: DataStreamRepository
    @Autowired
    lateinit var carLogoutRepository: CarLogoutRepository
    @Autowired
    lateinit var carLoginRepository: CarLoginRepository
    lateinit var airDataRepository: AirDataRepository

    val vehicleDataDecoder = VehicleDataDecoder()
    val airDataDecoder = AirDataDecoder.instance
    val dataPackageDecoder = DataPackageDecoderImpl()

    @PostConstruct
    fun init() {
        instance = this
        instance.obdDataRepository = this.obdDataRepository
        instance.originDataRepository = this.originDataRepository
        instance.obdInfoRepository = this.obdInfoRepository
        instance.dataStreamRepository = this.dataStreamRepository
        instance.carLogoutRepository = this.carLogoutRepository
        instance.carLoginRepository = this.carLoginRepository
        airDataRepository = this.airDataRepository
    }

    fun dealStringMsg(msg: String, ctx: ChannelHandlerContext?) {
        //解包
        val packageData = vehicleDataDecoder.decode(msg)
        val packageData = airDataDecoder.decode(msg)

        saveToTxt(msg)

        val isCommand = command(packageData, ctx)

        if (isCommand) {
            println("------远程控制指令 [${SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(Date())}]")
        if (bccCheck(msg)) {
            //保存
            DeviceSession.saveDevice(packageData.deviceCode, ctx)
            saveToTxt(msg)
            saveToDataBase(packageData)
        } else {
            if (bccCheck(msg)) {
                //保存
                DeviceSession.saveDevice(packageData.deviceCode, ctx)
                saveToDataBase(packageData, msg)
            } else {
                println("------数据BCC校验失败，舍弃 [${SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(Date())}]")
            }
            println("------${TAG}数据BCC校验失败，舍弃 [${SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(Date())}]")
        }
    }

@@ -89,27 +66,9 @@
    /**
     * 保存至数据库
     */
    fun saveToDataBase(packageData: ObdPackageData, msg: String) {
//        instance.obdDataRepository.saveObdData(packageData)
        instance.originDataRepository.saveOriginData(packageData, msg)
        when (packageData.commandUnit) {
            ObdCommandUnit.CarRegister.value -> instance.carLoginRepository.saveCarLogin(packageData)
            ObdCommandUnit.RealTimeData.value,
            ObdCommandUnit.ReplacementData.value -> {
                var done = false
                for (i in 0 until packageData.dataUnit.size) {
                    when (packageData.dataUnit[i]) {
                        is ObdInfo -> instance.obdInfoRepository.saveObdInfo(packageData)
                        is EngineDataStream,
                        is SupplementDataStream -> {
                            instance.dataStreamRepository.saveDataStream(packageData)
                            done = true
                        }
                    }
                    if (done) break
                }
            }
            ObdCommandUnit.CarLogOut.value-> instance.carLogoutRepository.saveCarLogout(packageData)
    fun saveToDataBase(dataPackage: AirDataPackage) {
        when (dataPackage.commandUnit) {
            AirCommandUnit.AirData.value -> instance.airDataRepository.saveAirData(dataPackage)
        }
    }

@@ -119,15 +78,13 @@
    fun bccCheck(msg: String):Boolean {
        val list = mutableListOf<String>().apply {
            addAll(dataPackageDecoder.toStringList(msg))
            //去除2 位起始符
            removeAt(0)
            removeAt(0)
        }
        //取得数据包中的bcc校验结果
        val oldBcc = list[list.size - 1].toInt(16)
        val oldBcc = "${list[list.lastIndex - 1]}${list[list.lastIndex]}".toInt(16)

        //去除校验结果
        list.removeAt(list.size-1)
        list.removeAt(list.lastIndex)
        list.removeAt(list.lastIndex)

        //计算bcc校验结果
        var newBcc = 0x00
@@ -139,37 +96,6 @@
        return oldBcc == newBcc
    }

    /**
     * 远程指令
     */
    fun command(packageData: ObdPackageData, ctx: ChannelHandlerContext?): Boolean {
        if (packageData.commandUnit == ObdCommandUnit.Update.value) {
            val channel = DeviceSession.getDevice(packageData.deviceCode)
            if (channel != null) {
                val s = getDataPackage(packageData.deviceCode)
                if (s == null) {
                    ctx?.writeAndFlush("[${packageData.deviceCode}] 设备编号为空")
                } else {
                    val bytes = encodeToBytes(s)
                    channel.writeAndFlush(Unpooled.copiedBuffer(bytes))
                    ctx?.writeAndFlush("[${packageData.deviceCode}] 指令发送成功")
                }
            } else {
                ctx?.writeAndFlush("[${packageData.deviceCode}] 设备未连接或不存在")
            }
            return true
        } else if (packageData.commandUnit != ObdCommandUnit.CarRegister.value
                && packageData.commandUnit != ObdCommandUnit.RealTimeData.value
                && packageData.commandUnit != ObdCommandUnit.ReplacementData.value
                && packageData.commandUnit != ObdCommandUnit.CarLogOut.value
                && packageData.commandUnit != ObdCommandUnit.TimeCalibration.value) {
            ctx?.writeAndFlush("[${packageData.deviceCode}] 命令不存在")

            return true
        } else {
            return false
        }
    }

    fun encodeToBytes(msg:String): ByteArray {
        val list = msg.split(" ")