2026.4.9

feiyu02

7 天以前 594de76ed51fd49fb79b912212bb0052a63e7671

 src/main/kotlin/com/flightfeather/uav/domain/repository/impl/AirDataRepImpl.kt

@@ -35,11 +35,11 @@
    private val tmpVehicleDataList = mutableListOf<BaseRealTimeData>()

    // 走航监测校准系数
    private val calibrationMap = mutableMapOf<String, MutableMap<Int, Float>>()
    private val calibrationMap = mutableMapOf<String?, MutableMap<Int, Float>>()
    // 走航监测校准系数更新时间
    private var cUpdateTime = LocalDateTime.now()
    // 走航监测校准系数更新时间间隔（分钟）
    private val cInterval = 5L
    private val cInterval = 1L

    override fun saveAirData(dataPackage: AirDataPackage): Int {
        val data = RealTimeData().apply {
@@ -127,23 +127,21 @@
        return count
    }

    override fun savePrepData2(dataList: List<DataVo>): Int {
        var count = 0
    override fun savePrepData2(dataList: List<DataVo>): List<BaseRealTimeData> {
        val res = mutableListOf<BaseRealTimeData>()
        dataList.forEach {vo ->
            when (UWDeviceType.getType(vo.deviceCode)) {
                UWDeviceType.VEHICLE -> {
                    val d = RealTimeDataVehicle()
                    dataTransform(vo, d)
                    val d = vo.toBaseRealTimeData(RealTimeDataVehicle::class.java)
                    /***************************************************************************************************/
                    // FIXME: 2021/10/27 车载监测部分因子量级调整
                    calibration(d, UWDeviceType.VEHICLE)
                    calibration(d, d.deviceCode)
                    /***************************************************************************************************/
                    realTimeDataVehicleMapper.insert(d)
                    count++
                    res.add(d)
                }
                UWDeviceType.UAV -> {
                    val d = RealTimeDataUav()
                    dataTransform(vo, d)
                    val d = vo.toBaseRealTimeData(RealTimeDataUav::class.java)
                    /***************************************************************************************************/
                    // FIXME: 2021/10/25 无人机部分因子采用车载数据填充，取最新的15分钟的数据
                    if (tmpVehicleDataList.isEmpty()) {
@@ -164,11 +162,10 @@
                    }
                    /***************************************************************************************************/
                    realTimeDataUavMapper.insert(d)
                    count++
                    res.add(d)
                }
                UWDeviceType.GRID -> {
                    val d = RealTimeDataGrid()
                    dataTransform(vo, d)
                    val d = vo.toBaseRealTimeData(RealTimeDataGrid::class.java)
                    /**************************************************************************/
                    // FIXME: 2021/11/8 针对历史网格化原始数据，进行临时校准处理
//                    val dTime = LocalDateTime.ofInstant(d.dataTime?.toInstant(), ZoneId.systemDefault())
@@ -196,7 +193,7 @@
//                    d.h2s = d.h2s?.let { sqrt(it) * 2 }
                    /**************************************************************************/
                    realTimeDataGridMapper.insert(d)
                    count++
                    res.add(d)
                }
                UWDeviceType.BOAT -> {

@@ -204,7 +201,7 @@
                else -> Unit
            }
        }
        return count
        return res
    }

    private fun dataTransform(vo: RealTimeData, bean: BaseRealTimeData) {
@@ -270,52 +267,20 @@
        }
    }

    fun dataTransform(vo: DataVo, bean: BaseRealTimeData) {
        bean.apply {
            deviceCode = vo.deviceCode
            latitude = vo.lat?.toBigDecimal()
            longitude = vo.lng?.toBigDecimal()
            dataTime = SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(vo.time)
            createTime = Date()
            vo.values?.forEach {
                when (it.factorId?.toInt()) {
                    FactorType.NO2.value -> no2 = it.factorData?.toFloat()
                    FactorType.CO.value -> co = it.factorData?.toFloat()
                    FactorType.H2S.value -> h2s = it.factorData?.toFloat()
                    FactorType.SO2.value -> so2 = it.factorData?.toFloat()
                    FactorType.O3.value -> o3 = it.factorData?.toFloat()

                    FactorType.PM25.value -> pm25 = it.factorData?.toFloat()
                    FactorType.PM10.value -> pm10 = it.factorData?.toFloat()
                    FactorType.TEMPERATURE.value -> temperature = it.factorData?.toFloat()
                    FactorType.HUMIDITY.value -> humidity = it.factorData?.toFloat()
                    FactorType.VOC.value -> voc = it.factorData?.toFloat()

                    FactorType.NOI.value -> noi = it.factorData?.toFloat()
                    FactorType.VELOCITY.value -> velocity = it.factorData?.toFloat()
                    FactorType.WIND_SPEED.value -> windSpeed = it.factorData?.toFloat()
                    FactorType.WIND_DIRECTION.value -> windDirection = it.factorData?.toFloat()
                    FactorType.HEIGHT.value -> height = it.factorData?.toFloat()
                }
            }

        }
    }

    private fun calibration(data: BaseRealTimeData, type: UWDeviceType) {
    private fun calibration(data: BaseRealTimeData, deviceCode: String?) {
        //1. 校准系数按照一定时间间隔进行刷新
        val now = LocalDateTime.now()
        if (calibrationMap.isEmpty() || now.minusMinutes(cInterval).isAfter(cUpdateTime)) {
        if (calibrationMap[deviceCode].isNullOrEmpty() || now.minusMinutes(cInterval).isAfter(cUpdateTime)) {
            cUpdateTime = now
            calibrationMap[type.value] = mutableMapOf()
            calibrationMap[deviceCode] = mutableMapOf()
            factorCalibrationMapper.selectByExample(Example(FactorCalibration::class.java).apply {
                createCriteria().andEqualTo("deviceType", type.value)
                createCriteria().andEqualTo("deviceType", deviceCode)
            }).forEach {
                calibrationMap[type.value]?.put(it.factorId, it.factorScale)
                calibrationMap[deviceCode]?.put(it.factorId, it.factorScale)
            }
        }
        //2. 根据校准系数计算
        calibrationMap[type.value]?.let{
        calibrationMap[deviceCode]?.let {
            data.voc = data.voc?.times(it[FactorType.VOC.value] ?: 1f)
            data.co = data.co?.times(it[FactorType.CO.value] ?: 1f)
            data.pm25 = data.pm25?.times(it[FactorType.PM25.value] ?: 1f)