package com.whyc.service;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.github.pagehelper.PageHelper;
|
import com.github.pagehelper.PageInfo;
|
import com.whyc.constant.ExperimentType;
|
import com.whyc.dto.ExperimentConditionDTO;
|
import com.whyc.dto.Response;
|
import com.whyc.mapper.*;
|
import com.whyc.pojo.Experiment;
|
import com.whyc.pojo.ExperimentBaseDataKZ;
|
import com.whyc.pojo.ExperimentPoint;
|
import com.whyc.pojo.ExperimentPrecondition;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.annotation.Resource;
|
import java.text.SimpleDateFormat;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.concurrent.atomic.AtomicBoolean;
|
import java.util.concurrent.atomic.AtomicReference;
|
|
import static java.lang.Thread.sleep;
|
|
@Service
|
@Slf4j
|
public class ExperimentService {
|
|
@Resource
|
private ExperimentMapper mapper;
|
@Resource
|
private ExperimentBaseDataKZMapper kzMapper;
|
@Resource
|
private ExperimentPointMapper pointMapper;
|
@Resource
|
private ExperimentPreconditionMapper preconditionMapper;
|
@Resource
|
private CommonMapper commonMapper;
|
|
public Response exist() {
|
ExperimentConditionDTO condition = new ExperimentConditionDTO();
|
condition.setStatus(1);
|
List<Experiment> experiments = mapper.getList(condition);
|
//不存在试验
|
if (experiments.isEmpty()){
|
return new Response().setMsg(-1,"暂无试验");
|
}
|
Experiment experiment = experiments.get(0);
|
String url = null;
|
if (experiment.getId().toLowerCase().contains(ExperimentType.KZ.getValue())){
|
url = "noLoadTest";
|
}
|
else if(experiment.getId().toLowerCase().contains(ExperimentType.FZ.getValue())){
|
url = "loadTest";
|
}
|
else if(experiment.getId().toLowerCase().contains(ExperimentType.RZ.getValue())){
|
url = "windingTest";
|
}else{
|
url ="不存在呀";
|
}
|
return new Response().set(1,experiments.get(0),url);
|
}
|
|
/**
|
* 绕组:rz,
|
* 空载:kz,
|
* 负载:fz,
|
* 升温:sw,
|
* 超速:cs,
|
* 空载反电动势:kzfdds,
|
* 振动:zd,
|
* 耐压:ny,
|
* 转动惯量:zdgl
|
* @param type
|
* @return
|
*/
|
public Response getExperimentId(String type) {
|
String id = null;
|
//查询当前试验类型的最大编号
|
QueryWrapper<Experiment> wrapper = Wrappers.query();
|
Date now = new Date();
|
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
|
String nowFormat = dateFormat.format(now);
|
String idLike = type.toUpperCase()+"_"+nowFormat;
|
wrapper.select("id").likeRight("id",idLike).orderByDesc("id").last(" limit 1");
|
Experiment experiment = mapper.selectOne(wrapper);
|
if(experiment!=null) {
|
int idPrefixLength = idLike.length();
|
String idSuffixStr = experiment.getId().substring(idPrefixLength);
|
Integer idSuffix = Integer.parseInt(idSuffixStr)+1;
|
//前面填充0的位数
|
int zeroCount = idSuffixStr.length()-idSuffix.toString().length();
|
StringBuilder zeroStr = new StringBuilder();
|
for (int i = 0; i < zeroCount; i++) {
|
zeroStr.append("0");
|
}
|
id = idLike+zeroStr+idSuffix;
|
}else{
|
id = idLike+"001";
|
}
|
return new Response().set(1,id);
|
|
}
|
|
@Transactional
|
public Response addKZFZ(Experiment experiment) {
|
//插入experiment数据
|
experiment.setCreateTime(new Date());
|
//新增初始化状态为0未开始,正在进行
|
experiment.setStatus(0);
|
mapper.insert(experiment);
|
|
//插入experiment_base_data数据
|
kzMapper.insert((ExperimentBaseDataKZ) experiment.getBaseData());
|
|
//插入experiment_point数据
|
List<ExperimentPoint> points = (List<ExperimentPoint>) experiment.getPoint();
|
points.stream().forEach(p->p.setStatus(0));
|
pointMapper.insertBatchSomeColumn(points);
|
//TODO 插入紧急停止数据
|
|
return new Response().setMsg(1,"新增成功");
|
}
|
|
/**
|
* 检查前置条件
|
* @param type
|
* @return
|
*/
|
public Response checkPrecondition(String type) {
|
AtomicReference<Integer> code = new AtomicReference<>(1);
|
//2种方式
|
//m1
|
QueryWrapper<ExperimentPrecondition> wrapper = Wrappers.query();
|
wrapper.eq("type",type).eq("flag",1);
|
List<ExperimentPrecondition> preconditions = preconditionMapper.selectList(wrapper);
|
preconditions.stream().forEach(precondition->{
|
//获取对应的值
|
/*ExperimentPrecondition preconditionStatus = commonMapper.getPreconditionStatus(precondition);
|
precondition.setActualValue(preconditionStatus.getActualValue());
|
precondition.setStatus(preconditionStatus.getStatus());*/
|
Object preconditionActualValue = commonMapper.getPreconditionStatus(precondition);
|
/*String preconditionActualValueStr = preconditionActualValue.toString();
|
if(precondition.getValue().equals(preconditionActualValueStr)){*/
|
//采用浮点/整型进行数值对比
|
if(preconditionActualValue instanceof Integer) {
|
Integer actualValue = (Integer) preconditionActualValue;
|
Integer defaultValue = Integer.parseInt(precondition.getValue());
|
|
if (defaultValue.equals(actualValue)) {
|
precondition.setStatus(1);
|
} else {
|
precondition.setStatus(0);
|
code.set(-1);
|
}
|
precondition.setActualValue(actualValue.toString());
|
}
|
else if(preconditionActualValue instanceof Float) {
|
Float actualValue = (Float) preconditionActualValue;
|
Float defaultValue = Float.parseFloat(precondition.getValue());
|
|
if (defaultValue.equals(actualValue)) {
|
precondition.setStatus(1);
|
} else {
|
precondition.setStatus(0);
|
code.set(-1);
|
}
|
precondition.setActualValue(actualValue.toString());
|
}
|
});
|
return new Response().set(code.get(),preconditions);
|
}
|
|
/**
|
* 检查中置条件-当前功率和当前定子温度,如果符合标准,返回当前值
|
*/
|
public Response checkPreconditionStep1(String experimentId){
|
String type = experimentId.split("_")[0].toLowerCase();
|
QueryWrapper<ExperimentPrecondition> wrapper = Wrappers.query();
|
wrapper.eq("type",type+"_1");
|
List<ExperimentPrecondition> preconditions = preconditionMapper.selectList(wrapper);
|
|
//获取到条件数量
|
int conditionNum = preconditions.size();
|
AtomicReference<Integer> passNum = new AtomicReference(0);
|
while (conditionNum!=passNum.get()) {
|
//重置为0
|
passNum.set(0);
|
preconditions.stream().forEach(precondition -> {
|
//获取对应的值
|
Object preconditionActualValue = commonMapper.getPreconditionStatus(precondition);
|
//采用浮点/整型进行数值对比
|
if(preconditionActualValue instanceof Float) {
|
Float actualValue = (Float) preconditionActualValue;
|
Float defaultValue = Float.parseFloat(precondition.getValue());
|
|
if (defaultValue.equals(actualValue)) {
|
//条件达成,达成数上+1
|
passNum.set(passNum.get() + 1);
|
//记录当前值
|
precondition.setActualValue(actualValue.toString());
|
}
|
}
|
//采用浮点/整型进行数值对比
|
if(preconditionActualValue instanceof Integer) {
|
Integer actualValue = (Integer) preconditionActualValue;
|
Integer defaultValue = Integer.parseInt(precondition.getValue());
|
|
if (defaultValue.equals(actualValue)) {
|
//条件达成,达成数上+1
|
passNum.set(passNum.get() + 1);
|
//记录当前值
|
precondition.setActualValue(actualValue.toString());
|
}
|
}
|
});
|
}
|
//演示需要
|
try {
|
sleep(5000);
|
} catch (InterruptedException e) {
|
e.printStackTrace();
|
}
|
//设置试验整体状态为1,启动时间更新
|
mapper.updateStatusAndTime(experimentId,1,"start_time",new Date());
|
return new Response().set(1,preconditions);
|
}
|
|
/**
|
* 开始试验,更新 试验状态和启动试验时间
|
*/
|
public Response updateStatus(String experimentId){
|
Experiment<Object, Object> experiment = new Experiment<>();
|
experiment.setId(experimentId);
|
experiment.setStatus(1);
|
experiment.setStartTime(new Date());
|
mapper.updateById(experiment);
|
return new Response().set(1,"状态更新成功");
|
}
|
|
/**
|
* 获取测试点
|
*/
|
public Response<List<ExperimentPoint>> getPoint(String experimentId){
|
QueryWrapper<ExperimentPoint> wrapper = Wrappers.query();
|
wrapper.eq("experiment_id",experimentId);
|
List<ExperimentPoint> experimentPoints = pointMapper.selectList(wrapper);
|
/*//TODO 针对已完成的测试点,计算出这段时间内的平均功率并返回,需要考虑是否将功率字段持久化到表中
|
experimentPoints.stream().forEach(point -> {
|
if(point.getStatus()==2){
|
//计算出平均功率并赋值
|
int power = (int) (100 + Math.random() * 10);
|
point.setAveragePower(power);
|
}
|
});*/
|
return new Response<List<ExperimentPoint>>().set(1,experimentPoints);
|
}
|
|
/**
|
* 更新测试点的开始时间和状态
|
*/
|
public Response updatePointStatus(ExperimentPoint experimentPoint){
|
pointMapper.updateById(experimentPoint);
|
return new Response().set(1,"状态更新成功");
|
}
|
|
/**
|
* 启动测试点,并在测试时长过后,返回测试结果
|
* 测试点的结束,结束分两种情况:
|
* 情况一:经过预定的测试时长,停止
|
* 情况二:更新了数据库的某个字段,代码循环判断这个字段,如果为2则停止实验并返回结果
|
* @return
|
*/
|
public Response startExperimentPoint(ExperimentPoint point){
|
//更新测试时间和测试点状态
|
point.setStartTime(new Date());
|
point.setStatus(1);
|
pointMapper.updateById(point);
|
//等待duration时间
|
Integer duration = point.getDuration();
|
Integer durationSecond = duration*60;
|
final boolean[] threadStatus = {true};
|
//采用线程的原因是非线程sleep后无法执行手动结束条件判断代码
|
Thread t = new Thread(){
|
@Override
|
public void run() {
|
try {
|
sleep(durationSecond*1000);
|
threadStatus[0] = false;
|
} catch (InterruptedException e) {
|
interrupt();
|
log.warn("t1线程被打断");
|
//e.printStackTrace();
|
}
|
};
|
};
|
t.start();
|
|
boolean statusFlag =true;
|
//手动停止和测试点预设时间,1个条件成立就终止测试
|
while(statusFlag && threadStatus[0]){
|
//查询测试点状态是否被打断
|
QueryWrapper<ExperimentPoint> wrapper = Wrappers.query();
|
wrapper.select("status").eq("id",point.getId());
|
ExperimentPoint currentPoint = pointMapper.selectOne(wrapper);
|
if(currentPoint.getStatus()==3){
|
statusFlag = false;
|
}
|
}
|
log.warn("测试点结束");
|
if (t.isAlive()) {
|
t.interrupt();
|
}
|
|
/*try {
|
//sleep(durationSecond);
|
//演示需要,使用5s
|
sleep(5000);
|
|
} catch (InterruptedException e) {
|
e.printStackTrace();
|
}*/
|
pointMapper.updateEndTime(point.getId(),new Date());
|
//返回这段时间的测试结果
|
//TODO 这段时间内的数据,需要进行动态计算
|
int value = (int) (100 + Math.random() * 10);
|
ExperimentPoint pointTemp = new ExperimentPoint();
|
pointTemp.setId(point.getId());
|
pointTemp.setAveragePower(value);
|
pointMapper.updateById(pointTemp);
|
return new Response().setMsg(1,"测试点结束");
|
}
|
|
|
public Response finishExperiment(String experimentId) {
|
mapper.updateStatusAndTime(experimentId,2,"end_time",new Date());
|
return new Response().setMsg(1,"状态更新成功");
|
}
|
|
public Response finishExperimentPoint(Integer id) {
|
ExperimentPoint point = new ExperimentPoint();
|
point.setId(id);
|
//中断信号
|
point.setStatus(3);
|
pointMapper.updateById(point);
|
return new Response().setMsg(1,"测试点中断信号更新成功");
|
}
|
|
public Response restartExperimentPoint(Integer id) {
|
ExperimentPoint point = new ExperimentPoint();
|
point.setId(id);
|
point.setStatus(0);
|
point.setStartTime(null);
|
point.setEndTime(null);
|
point.setAveragePower(null);
|
pointMapper.updateById(point);
|
return new Response().setMsg(1,"重置测试点成功");
|
}
|
|
public Response setPrecondition(Integer id,Integer value) {
|
switch (id){
|
case 1:{
|
commonMapper.setPrecondition("`db_3.5mw_motor`.tb_central_monitor_sys_rt","10001","switch_close",value.toString());
|
break;
|
}
|
case 2:{
|
commonMapper.setPrecondition("`db_3.5mw_motor`.tb_rectifier_power_rt","30001","rectifier_vol",value.toString());
|
break;
|
}
|
case 3:{
|
commonMapper.setPrecondition("`db_3.5mw_motor`.tb_central_monitor_sys_st","10005","vol_a",value.toString());
|
break;
|
}
|
case 4:{
|
commonMapper.setPrecondition("`db_3.5mw_motor`.tb_central_monitor_sys_st","10005","vol_b",value.toString());
|
break;
|
}
|
case 5:{
|
commonMapper.setPrecondition("`db_3.5mw_motor`.tb_device_state","40001","comm_status",value.toString());
|
break;
|
}
|
case 6:{
|
commonMapper.setPrecondition("`db_3.5mw_motor`.tb_device_state","40002","comm_status",value.toString());
|
break;
|
}
|
case 7:{
|
commonMapper.setPrecondition("`db_3.5mw_motor`.tb_device_state","50001","comm_status",value.toString());
|
break;
|
}
|
}
|
return new Response().setMsg(1,"设置完成");
|
}
|
|
/*======History======*/
|
|
public Response<PageInfo<Experiment>> getPage(Integer pageNum, Integer pageSize, ExperimentConditionDTO condition) {
|
condition.setStatus(2);
|
PageHelper.startPage(pageNum,pageSize);
|
List<Experiment> experimentList = mapper.getList(condition);
|
//查询结果的duration是分钟,转换为 x时x分格式
|
experimentList.stream().forEach(experiment -> {
|
int duration = Integer.parseInt(experiment.getDuration());
|
//获取时
|
int hour = duration/60;
|
//获取分
|
int minute = duration%60;
|
experiment.setDuration(hour+"小时"+minute+"分");
|
});
|
|
PageInfo<Experiment> pageInfo = new PageInfo<>(experimentList);
|
return new Response<PageInfo<Experiment>>().set(1,pageInfo);
|
}
|
|
}
|
