baifengji
/
separate-gold-service
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

1、手动停止降温关闭加热棒 

2、工艺预热关闭降温
3、手动加热 烘干 退火关闭风扇
4、设置温度增加非空判断
5、工艺分页增加排序
6、预热分为退火位和加热位
7、工艺开始增加对加热位托盘的判断
master
王梦远 1 month ago
parent
6279af6a2a
commit
1225889490
16 changed files with 99 additions and 198 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      src/main/java/com/iflytop/sgs/app/cmd/control/AnnealStartCommand.java
  2. 2
      src/main/java/com/iflytop/sgs/app/cmd/control/DrainLiquidCommand.java
  3. 2
      src/main/java/com/iflytop/sgs/app/cmd/control/DryStartCommand.java
  4. 8
      src/main/java/com/iflytop/sgs/app/cmd/control/FanStartCommand.java
  5. 2
      src/main/java/com/iflytop/sgs/app/cmd/control/HeatStartCommand.java
  6. 2
      src/main/java/com/iflytop/sgs/app/controller/CraftsController.java
  7. 15
      src/main/java/com/iflytop/sgs/app/controller/HeatController.java
  8. 2
      src/main/java/com/iflytop/sgs/app/core/BaseCommandHandler.java
  9. 19
      src/main/java/com/iflytop/sgs/app/service/api/CraftsService.java
  10. 13
      src/main/java/com/iflytop/sgs/app/service/api/HeatService.java
  11. 194
      src/main/java/com/iflytop/sgs/app/service/crafts/CraftsStepService.java
  12. 11
      src/main/java/com/iflytop/sgs/app/service/device/module/TransferModuleService.java
  13. 2
      src/main/java/com/iflytop/sgs/common/enums/CraftsTransferTypeCode.java
  14. 8
      src/main/java/com/iflytop/sgs/common/enums/SystemConfigCode.java
  15. 12
      src/main/java/com/iflytop/sgs/common/enums/data/CraftsPreHeatType.java
  16. 3
      src/main/java/com/iflytop/sgs/common/result/ResultCode.java

2
src/main/java/com/iflytop/sgs/app/cmd/control/AnnealStartCommand.java
View File

@ -40,6 +40,8 @@ public class AnnealStartCommand extends BaseCommandHandler {
throw new AppException(ResultCode.HEAT_TEMPERATURE_NULL);
}
return runAsync(() -> {
heatModuleService.fanClose(cmdDTO.getCommandId(), cmdDTO.getCommand(), heatModuleCode);//关闭风扇
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setFanOpen(false);//同步状态
heatModuleService.heatRodOpen(cmdDTO.getCommandId(), cmdDTO.getCommand(), heatModuleCode, targetTemperature);//开启加热
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setHeatingType(HeatingType.annealing);//状态修改为退火中
heatModuleState.setTargetTemperature(targetTemperature);//将退火温度设定为目标温度

2
src/main/java/com/iflytop/sgs/app/cmd/control/DrainLiquidCommand.java
View File

@ -8,7 +8,6 @@ import com.iflytop.sgs.app.service.api.DevicePositionService;
import com.iflytop.sgs.app.service.api.SystemConfigService;
import com.iflytop.sgs.app.service.device.DeviceSensorService;
import com.iflytop.sgs.app.service.device.DeviceStateService;
import com.iflytop.sgs.app.service.device.module.HeatModuleService;
import com.iflytop.sgs.app.service.device.module.SolutionModuleService;
import com.iflytop.sgs.app.service.device.module.TransferModuleService;
import com.iflytop.sgs.common.annotation.CommandMapping;
@ -33,7 +32,6 @@ import java.util.concurrent.CompletableFuture;
@RequiredArgsConstructor
@CommandMapping("drain_liquid")//业务指令注解
public class DrainLiquidCommand extends BaseCommandHandler {
private final HeatModuleService heatModuleService;
private final TransferModuleService transferModuleService;
private final DevicePositionService devicePositionService;

2
src/main/java/com/iflytop/sgs/app/cmd/control/DryStartCommand.java
View File

@ -37,6 +37,8 @@ public class DryStartCommand extends BaseCommandHandler {
throw new AppException(ResultCode.HEAT_TEMPERATURE_NULL);
}
return runAsync(() -> {
heatModuleService.fanClose(cmdDTO.getCommandId(), cmdDTO.getCommand(), heatModuleCode);//关闭风扇
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setFanOpen(false);//同步状态
heatModuleService.heatRodOpen(cmdDTO.getCommandId(), cmdDTO.getCommand(), heatModuleCode, targetTemperature);
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setHeatingType(HeatingType.drying); //设置加热区状态 烘干中
heatModuleState.setTargetTemperature(targetTemperature);//将烘干温度设定为目标温度

8
src/main/java/com/iflytop/sgs/app/cmd/control/FanStartCommand.java
View File

@ -1,7 +1,6 @@
package com.iflytop.sgs.app.cmd.control;
import com.iflytop.sgs.app.core.BaseCommandHandler;
import com.iflytop.sgs.app.model.bo.status.device.HeatModuleState;
import com.iflytop.sgs.app.model.dto.CmdDTO;
import com.iflytop.sgs.app.service.device.DeviceStateService;
import com.iflytop.sgs.app.service.device.module.HeatModuleService;
@ -30,13 +29,10 @@ public class FanStartCommand extends BaseCommandHandler {
String heatModuleCodeStr = cmdDTO.getStringParam("heatModuleCode");
HeatModuleCode heatModuleCode = HeatModuleCode.valueOf(heatModuleCodeStr);
HeatModuleState heatModuleState = deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode);
return runAsync(() -> {
if (!heatModuleState.getHeatingType().equals(HeatingType.stop)) {//加热棒加热状态
heatModuleService.heatRodClose(cmdDTO.getCommandId(), cmdDTO.getCommand(), heatModuleCode);//关闭加热棒
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setHeatingType(HeatingType.stop);//同步状态
}
heatModuleService.heatRodClose(cmdDTO.getCommandId(), cmdDTO.getCommand(), heatModuleCode);//关闭加热棒
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setHeatingType(HeatingType.stop);//同步状态
heatModuleService.fanStart(cmdDTO.getCommandId(), cmdDTO.getCommand(), heatModuleCode);//打开风扇
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setFanOpen(true);//同步状态
});

2
src/main/java/com/iflytop/sgs/app/cmd/control/HeatStartCommand.java
View File

@ -37,6 +37,8 @@ public class HeatStartCommand extends BaseCommandHandler {
throw new AppException(ResultCode.HEAT_TEMPERATURE_NULL);
}
return runAsync(() -> {
heatModuleService.fanClose(cmdDTO.getCommandId(), cmdDTO.getCommand(), heatModuleCode);//关闭风扇
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setFanOpen(false);//同步状态
heatModuleService.heatRodOpen(cmdDTO.getCommandId(), cmdDTO.getCommand(), heatModuleCode, targetTemperature);//打开加热棒
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setHeatingType(HeatingType.heating); //设置加热区状态 加热中
heatModuleState.setTargetTemperature(targetTemperature);//将加热温度设定为目标温度

2
src/main/java/com/iflytop/sgs/app/controller/CraftsController.java
View File

@ -38,7 +38,7 @@ public class CraftsController {
private final CraftsService craftsService;
private final DeviceStateService deviceStateService;
@Operation(summary = "根据矿石id获取工艺列表")
@Operation(summary = "获取工艺列表")
@GetMapping("/list")
public PageResult<Crafts> getPage(BasePageQuery pageQuery) {
IPage<Crafts > result = craftsService.getPage(pageQuery);

15
src/main/java/com/iflytop/sgs/app/controller/HeatController.java
View File

@ -31,18 +31,15 @@ public class HeatController {
@Operation(summary = "加热模块设定目标温度")
@PostMapping("/target-temperature")
public Result<String> setTargetTemperature(@Valid @RequestBody SetTargetTemperatureVO setTargetTemperatureVO) {
Double annealTemperature = systemConfigService.getSystemConfigDoubleByCode(SystemConfigCode.anneal_temperature);//抽液时针下降高度
Double dryTemperature = systemConfigService.getSystemConfigDoubleByCode(SystemConfigCode.dry_temperature);//抽液时针下降高度
Double heatTemperature = systemConfigService.getSystemConfigDoubleByCode(SystemConfigCode.heat_temperature);//抽液时针下降高度
if(setTargetTemperatureVO.getHeatTemperature()>heatTemperature){
Double annealTemperature = systemConfigService.getSystemConfigDoubleByCode(SystemConfigCode.anneal_temperature);//退火温度极限值
Double dryTemperature = systemConfigService.getSystemConfigDoubleByCode(SystemConfigCode.dry_temperature);//烘干温度极限值
Double heatTemperature = systemConfigService.getSystemConfigDoubleByCode(SystemConfigCode.heat_temperature);//加热温度极限值
if (setTargetTemperatureVO.getHeatTemperature() != null && setTargetTemperatureVO.getHeatTemperature() > heatTemperature)
return Result.failed("加热温度超过设定值!");
}
if(setTargetTemperatureVO.getDryTemperature()>dryTemperature){
if (setTargetTemperatureVO.getDryTemperature() != null && setTargetTemperatureVO.getDryTemperature() > dryTemperature)
return Result.failed("烘干温度超过设定值!");
}
if(setTargetTemperatureVO.getAnnealTemperature()>annealTemperature){
if (setTargetTemperatureVO.getAnnealTemperature() != null && setTargetTemperatureVO.getAnnealTemperature() > annealTemperature)
return Result.failed("退火温度超过设定值");
}
heatModuleService.setTargetTemperature(setTargetTemperatureVO);
return Result.success();
}

2
src/main/java/com/iflytop/sgs/app/core/BaseCommandHandler.java
View File

@ -30,4 +30,4 @@ public abstract class BaseCommandHandler implements CommandHandler {
CompletableFuture.allOf(responseFutures)
.get(120, TimeUnit.SECONDS);
}
}
}

19
src/main/java/com/iflytop/sgs/app/service/api/CraftsService.java
View File

@ -20,6 +20,7 @@ import com.iflytop.sgs.app.model.vo.CraftMonitorVO;
import com.iflytop.sgs.app.model.vo.CraftStatusVO;
import com.iflytop.sgs.app.model.vo.SetCraftsVO;
import com.iflytop.sgs.app.service.crafts.CraftsStepService;
import com.iflytop.sgs.app.service.device.DeviceSensorService;
import com.iflytop.sgs.app.service.device.DeviceStateService;
import com.iflytop.sgs.app.service.device.module.HeatModuleService;
import com.iflytop.sgs.app.ws.server.WebSocketSender;
@ -63,10 +64,11 @@ public class CraftsService extends ServiceImpl<CraftsMapper, Crafts> {
private final ConcurrentHashMap<HeatModuleCode, CraftsContext> contextMap = new ConcurrentHashMap<>();
@Getter
private final ConcurrentHashMap<HeatModuleCode, Future<?>> futureMap = new ConcurrentHashMap<>();
private ExecutorService executor;
private final DeviceStateService deviceStateService;
private final ObjectProvider<CraftsState> craftsStateObjectProvider;
private final SystemConfigService systemConfigService;
private final DeviceSensorService deviceSensorService;
private ExecutorService executor;
@PostConstruct
public void init() {
@ -100,10 +102,15 @@ public class CraftsService extends ServiceImpl<CraftsMapper, Crafts> {
log.error("此加热区工艺正在执行中，不可重复开始执行。");
throw new AppException(ResultCode.CRAFT_RUNNING);
}
// if (futureMap.containsKey(heatModuleCode)) {//校验指定加热模块是否正在执行工艺
// log.error("工艺正在执行中，不可重复开始执行。");
// throw new AppException(ResultCode.CRAFT_RUNNING);
// }
}
try {
boolean heatTrayExist = deviceSensorService.getTrayStateByHeatModuleCode(heatModuleCode);//获取加热区托盘
if (heatTrayExist) {
throw new AppException(ResultCode.CRAFT_IDLE_HEAT_MODULE_NOT_FOUND);
}
} catch (Exception e) {
log.error("获取加热区传感器信号失败!");
throw new AppException(ResultCode.HARDWARE_ERROR);
}
//判断温度
Double coldTemperature = systemConfigService.getSystemConfigDoubleByCode(SystemConfigCode.fan_stop_temperature);//加热区能能够执行加热的最低温度
@ -329,6 +336,6 @@ public class CraftsService extends ServiceImpl<CraftsMapper, Crafts> {
Page<Crafts> craftsPage = new Page<>(pageQuery.getPageNum(), pageQuery.getPageSize());
// 分页查询矿石数据
return this.baseMapper.selectPage(craftsPage, new QueryWrapper<>());
return this.baseMapper.selectPage(craftsPage, new QueryWrapper<Crafts>().orderByDesc("create_time"));
}
}

13
src/main/java/com/iflytop/sgs/app/service/api/HeatService.java
View File

@ -16,14 +16,17 @@ public class HeatService {
private final DeviceStateService deviceStateService;
public void setTargetTemperature(SetTargetTemperatureVO setTargetTemperatureVO) {
HeatModuleState heatModuleState=deviceStateService.getDeviceState().getHeatModuleByCode(setTargetTemperatureVO.getModuleCode());
heatModuleState.setAnnealTemperature(setTargetTemperatureVO.getAnnealTemperature());
heatModuleState.setDryTemperature(setTargetTemperatureVO.getDryTemperature());
heatModuleState.setHeatTemperature(setTargetTemperatureVO.getHeatTemperature());
HeatModuleState heatModuleState = deviceStateService.getDeviceState().getHeatModuleByCode(setTargetTemperatureVO.getModuleCode());
if (setTargetTemperatureVO.getAnnealTemperature() != null)
heatModuleState.setAnnealTemperature(setTargetTemperatureVO.getAnnealTemperature());
if (setTargetTemperatureVO.getDryTemperature() != null)
heatModuleState.setDryTemperature(setTargetTemperatureVO.getDryTemperature());
if (setTargetTemperatureVO.getHeatTemperature() != null)
heatModuleState.setHeatTemperature(setTargetTemperatureVO.getHeatTemperature());
}
public void setEnable(SetHeatModuleEnableVO setHeatModuleEnableVO){
public void setEnable(SetHeatModuleEnableVO setHeatModuleEnableVO) {
deviceStateService.getDeviceState().getHeatModuleByCode(setHeatModuleEnableVO.getModuleCode()).setEnable(setHeatModuleEnableVO.getEnable());
}
}

194
src/main/java/com/iflytop/sgs/app/service/crafts/CraftsStepService.java
View File

@ -8,6 +8,7 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.iflytop.sgs.app.core.CraftsDebugGenerator;
import com.iflytop.sgs.app.model.bo.CraftsStep;
import com.iflytop.sgs.app.model.bo.Point3D;
import com.iflytop.sgs.app.model.bo.status.device.TrayState;
import com.iflytop.sgs.app.model.bo.status.device.TubeState;
import com.iflytop.sgs.app.model.entity.Container;
import com.iflytop.sgs.app.model.entity.CraftMonitor;
@ -24,6 +25,7 @@ import com.iflytop.sgs.app.ws.server.WebSocketSender;
import com.iflytop.sgs.common.constant.WebSocketMessageType;
import com.iflytop.sgs.common.enums.*;
import com.iflytop.sgs.common.enums.cmd.CmdBeepMode;
import com.iflytop.sgs.common.enums.data.CraftsPreHeatType;
import com.iflytop.sgs.common.enums.data.DevicePositionCode;
import com.iflytop.sgs.common.exception.AppException;
import com.iflytop.sgs.common.result.ResultCode;
@ -58,7 +60,7 @@ public class CraftsStepService {
private final SystemConfigService systemConfigService;
private final DeviceLightSoundService deviceLightSoundService;
private final CraftMonitorService craftMonitorService;
private DoorModuleService doorModuleService;
private final DoorModuleService doorModuleService;
/**
* 执行单个工艺步骤
@ -90,17 +92,30 @@ public class CraftsStepService {
* 退火区预热
* */
public boolean preHeat(HeatModuleCode heatModuleCode, JSONObject params, CraftMonitor craftMonitor) throws Exception {
Double temperature = params.getDouble("temperature");
log.info("工艺{},预热", HeatModuleCode.heat_module_04);
heatModuleService.heatRodOpen(HeatModuleCode.heat_module_04, temperature);
deviceStateService.getDeviceState().getHeatModuleByCode(HeatModuleCode.heat_module_04).setTargetTemperature(temperature);//设置加热温度
deviceStateService.getDeviceState().getHeatModuleByCode(HeatModuleCode.heat_module_04).setHeatingType(HeatingType.heating);//加热中
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(HeatModuleCode.heat_module_04.toString(), "退火区加热中", temperature));
String type = params.getStr("type");
CraftsPreHeatType preHeatType= CraftsPreHeatType.valueOf(type);
if(preHeatType.equals(CraftsPreHeatType.anneal)){
heatModuleService.fanClose(HeatModuleCode.heat_module_04);//关闭风扇
deviceStateService.getDeviceState().getHeatModuleByCode(HeatModuleCode.heat_module_04).setFanOpen(false);//同步状态
heatModuleService.heatRodOpen(HeatModuleCode.heat_module_04, temperature);
deviceStateService.getDeviceState().getHeatModuleByCode(HeatModuleCode.heat_module_04).setTargetTemperature(temperature);//设置加热温度
deviceStateService.getDeviceState().getHeatModuleByCode(HeatModuleCode.heat_module_04).setHeatingType(HeatingType.heating);//加热中
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(HeatModuleCode.heat_module_04.toString(), "退火区预热中", temperature));
}else{
heatModuleService.fanClose(heatModuleCode);//关闭风扇
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setFanOpen(false);//同步状态
heatModuleService.heatRodOpen(heatModuleCode, temperature);
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setTargetTemperature(temperature);//设置加热温度
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setHeatingType(HeatingType.heating);//加热中
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "加热区预热中", temperature));
}
return true;
}
/*
* 执行加稀硝酸 浓硝酸 清洗前关门 前端开门按钮设置为不可操作
* 执行加稀硝酸 浓硝酸 清洗前关门 前端 开门 按钮设置为不可操作
* */
public void doorClose() throws HardwareException, InterruptedException {
doorModuleService.doorClose();
@ -112,7 +127,7 @@ public class CraftsStepService {
}
/*
* 执行加稀硝酸 浓硝酸 清洗后关门 前端开门按钮设置为可操作
* 执行加稀硝酸 浓硝酸 清洗后关门 前端 开门 按钮设置为可操作
* */
public void doorAble() {
deviceStateService.getDeviceState().getDoorModule().setActionable(true);
@ -126,16 +141,13 @@ public class CraftsStepService {
/*关门*/
doorClose();
log.info("工艺{},-------------------------------------加稀硝酸-------------------------------------", heatModuleCode);
/*工艺监控*/
log.info("工艺{},工艺监控", heatModuleCode);
List<Integer> finishColumns = new ArrayList<>();
craftMonitor.setCurrentStepResult(CraftsMonitorResultCode.add_liquid_column.getDescription() + Arrays.toString(finishColumns.toArray()));
craftMonitorService.saveMonitor(craftMonitor);
/*工艺监控结束*/
/*获取配置信息*/
log.info("工艺{},获取配置信息", heatModuleCode);
deviceStateService.getDeviceState().getSolutionModule().setPumping(true);
Double transferModuleXPickTrayMoveDistance = devicePositionService.getPosition(DevicePositionCode.transferModuleXPickTrayMoveDistance).getDistance();//获取转运模块X轴拿取托盘进出卡槽移动距离
Point3D feedAreaTrayPoint3D = devicePositionService.getPosition(DevicePositionCode.feedAreaTrayPoint).getPoint3D();//获取上料区托盘夹取位置点
@ -152,13 +164,12 @@ public class CraftsStepService {
double scale = systemConfigService.getSystemConfigDoubleByCode(SystemConfigCode.valueOf(solutions.getCode()));//获取转换比
Double solutionModuleMotorDownInTubeAddPositon = devicePositionService.getPosition(DevicePositionCode.solutionModuleMotorDownInTubeAddPositon).getPositon(); //加液模块电机下降进入试管加液位置
double addLiquidDistance = volume * scale;
Point3D heatArea1TrayClawPoint = devicePositionService.getPosition(DevicePositionCode.heatArea1TrayClawPoint).getPoint3D();//加热位1坐标
Point3D heatArea1TrayClawPoint = devicePositionService.getPosition(DevicePositionCode.heatArea1TrayClawPoint).getPoint3D();//加热位1 坐标
Double liquidAreaPreFillPoint = devicePositionService.getPosition(DevicePositionCode.liquidAreaPreFillPoint).getPositon(); //预充时加液臂下降位置
Double backFlowDistance = systemConfigService.getSystemConfigDoubleByCode(SystemConfigCode.back_flow_distance);//防低落距离
double pumpNormalSpeed = systemConfigService.getSystemConfigDoubleByCode(SystemConfigCode.pump_normal_speed);//蠕动泵正常转速
/*获取参数结束*/
log.info("工艺{},申请转运模组并等待", heatModuleCode);
transferModuleService.requestTransferModule(CraftsTransferTypeCode.move_thin);//申请转运模组并等待
deviceStateService.getDeviceState().getTrayByHeatModuleCode(heatModuleCode).setUseArm(true);//使用机械臂标志
@ -166,51 +177,41 @@ public class CraftsStepService {
/*移动至加液区开始*/
boolean feedTrayExist = deviceSensorService.getSensorStatus(DeviceSensorCode.LIQUID_TRAY_EXIST);//获取上料区传感器状态
Assert.isTrue(feedTrayExist, () -> new AppException(ResultCode.FEED_AREA_NO_TRAY));
log.info("工艺{},加液机械臂上升", heatModuleCode);
solutionModuleService.solutionMotorMoveZero();//加液机械臂上升
transferModuleService.transferMoveZero();//z轴上升
log.info("工艺{},机械臂移动至上料区", heatModuleCode);
transferModuleService.transferMove(liquidAreaTrayPoint3D);//移动至加液时托盘位置点
boolean clawTrayExist = deviceSensorService.getSensorStatus(DeviceSensorCode.CLAW_TRAY_EXIST);//获取传感器状态
Assert.isTrue(!clawTrayExist, () -> new AppException(ResultCode.CRAFT_SOLUTION_EXIST_TRAY));//加液区无托盘
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "机械臂移动至上料区", feedAreaTrayPoint3D));
log.info("工艺{},将X轴移动至上料区托盘夹取点 + 进出卡槽移动距离", heatModuleCode);
transferModuleService.transferMoveZero();//z轴上升
transferModuleService.transferXMove(feedAreaTrayPoint3D.getX() + transferModuleXPickTrayMoveDistance);//将X轴移动至上料区托盘夹取点 + 进出卡槽移动距离
log.info("工艺{},Z轴下降至夹取点，使托盘落入石墨加热盘", heatModuleCode);
feedTrayExist = deviceSensorService.getSensorStatus(DeviceSensorCode.LIQUID_TRAY_EXIST);//获取上料区传感器状态
Assert.isTrue(feedTrayExist, () -> new AppException(ResultCode.FEED_AREA_NO_TRAY));
transferModuleService.transferZMove(feedAreaTrayPoint3D.getZ());//Z轴下降至夹取点，使托盘落入石墨加热盘
log.info("工艺{},X轴进入卡槽", heatModuleCode);
transferModuleService.transferXMoveBy(-transferModuleXPickTrayMoveDistance);//X轴进入卡槽
deviceStateService.getDeviceState().getSolutionModule().setFeedAreaTrayStatus(false);//加热区托盘状态
deviceStateService.getDeviceState().getTrayByHeatModuleCode(heatModuleCode).setInFeedArea(false);//托盘状态
log.info("工艺{},Z轴抬升至最高", heatModuleCode);
transferModuleService.transferZMoveZero();//Z轴抬升至最高
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "机械臂移动至加液区", DevicePositionCode.liquidAreaTrayPoint.name()));
log.info("工艺{},移动至加液时托盘位置点", heatModuleCode);
transferModuleService.transferMove(liquidAreaTrayPoint3D);//移动至加液时托盘位置点
deviceStateService.getDeviceState().getSolutionModule().setPumping(true);//正在加液
deviceStateService.getDeviceState().getTrayByHeatModuleCode(heatModuleCode).setInSolutionPositon(true);//托盘状态
boolean clawTrayExist = deviceSensorService.getSensorStatus(DeviceSensorCode.CLAW_TRAY_EXIST);//获取传感器状态
clawTrayExist = deviceSensorService.getSensorStatus(DeviceSensorCode.CLAW_TRAY_EXIST);//获取传感器状态
Assert.isTrue(clawTrayExist, () -> new AppException(ResultCode.CRAFT_SOLUTION_NO_TRAY));//加液区无托盘
/*移动至加液区结束*/
/*预充开始*/
log.info("工艺{},预充开始", heatModuleCode);
transferModuleService.transferXMove(heatArea1TrayClawPoint.getX());//转运模块移动至加热位1
log.info("工艺{},加液机械臂下降至预充位置", heatModuleCode);
feedTrayExist = deviceSensorService.getSensorStatus(DeviceSensorCode.LIQUID_TRAY_EXIST);//获取传感器状态
Assert.isTrue(!feedTrayExist, () -> new AppException(ResultCode.FEED_AREA_EXIST_TRAY));//上料区存在托盘
solutionModuleService.solutionMotorMove(liquidAreaPreFillPoint);//加液机械臂下降至至预充点位
log.info("工艺{},电磁阀对应通道打开", heatModuleCode);
solutionModuleService.liquidValveSwitch(SolutionCode.waste);//电磁阀对应通道打开
solutionModuleService.liquidPumpSetSpeed(pumpNormalSpeed);//设置泵的正常转速
log.info("工艺{},排空", heatModuleCode);
solutionModuleService.liquidPumpMove(-drainDistance);//排空
log.info("工艺{},电磁阀对应通道打开", heatModuleCode);
solutionModuleService.liquidValveSwitchByChannel(channel);//电磁阀对应通道打开
log.info("工艺{},预充", heatModuleCode);
solutionModuleService.liquidPumpMove(preFillDistance);//预充
solutionModuleService.liquidPumpMove(-backFlowDistance);//预充
log.info("工艺{},加液机械臂上升", heatModuleCode);
solutionModuleService.solutionMotorMoveZero();//加液机械臂上升
/*预充结束*/
@ -233,14 +234,10 @@ public class CraftsStepService {
for (int i = 0; i < columns.size(); i++) {
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "移动加液机械臂到指定试管", i));
double distance = Math.abs(columns.get(i) - 5) * trayTubeHorizontalSpacingDistance;//机械臂右移距离
log.info("工艺{},机械臂移动到试管位置{}", heatModuleCode, i);
transferModuleService.transferXMove(liquidAreaTrayPoint3D.getX() + distance);//机械臂移动到试管位置
log.info("工艺{},加液机械臂下降", heatModuleCode);
solutionModuleService.solutionMotorMove(solutionModuleMotorDownInTubeAddPositon);//加液机械臂下降
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "添加溶液", addLiquidDistance));
log.info("工艺{},加液", heatModuleCode);
solutionModuleService.liquidPumpMove(addLiquidDistance);//加液 position
log.info("工艺{},加液机械臂上升", heatModuleCode);
solutionModuleService.solutionMotorMoveZero();//加液机械臂上升
/*工艺监控开始*/
finishColumns.add(i);
@ -257,15 +254,11 @@ public class CraftsStepService {
boolean heatModuleTrayExist = deviceSensorService.getTrayStateByHeatModuleCode(heatModuleCode);//目标加热模块有无托盘
Assert.isTrue(!heatModuleTrayExist, () -> new AppException(ResultCode.CRAFT_HEAT_EXIST_TRAY));//提示被占用
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "机械臂移动至加热区", heatModuleCode));
log.info("工艺{},加液机械臂上升", heatModuleCode);
solutionModuleService.solutionMotorMoveZero();//加液机械臂上升
log.info("工艺{},将X轴移动至目标加热模块托盘夹取点", heatModuleCode);
transferModuleService.transferXMove(heatModuleTrayClawPoint3D.getX());//将X轴移动至目标加热模块托盘夹取点
heatModuleTrayExist = deviceSensorService.getTrayStateByHeatModuleCode(heatModuleCode);//目标加热模块有无托盘
Assert.isTrue(!heatModuleTrayExist, () -> new AppException(ResultCode.CRAFT_HEAT_EXIST_TRAY));//提示被占用
log.info("工艺{},Z轴下降至夹取点", heatModuleCode);
transferModuleService.transferZMove(heatModuleTrayClawPoint3D.getZ());//Z轴下降至夹取点，使托盘落入石墨加热盘
log.info("工艺{},X轴移出卡槽", heatModuleCode);
transferModuleService.transferXMoveBy(transferModuleXPickTrayMoveDistance);//X轴移出卡槽
transferModuleService.transferZMoveZero();//Z轴抬升至最高
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setTrayStatus(true);//加热区托盘状态
@ -291,18 +284,15 @@ public class CraftsStepService {
public boolean addThick(HeatModuleCode heatModuleCode, JSONObject params, CraftMonitor craftMonitor) throws Exception {
try {
log.info("工艺{},------------------------------加浓硝酸---------------------------", heatModuleCode);
/*关门*/
doorClose();
/*工艺监控*/
log.info("工艺{},工艺监控", heatModuleCode);
List<Integer> finishColumns = new ArrayList<>();
craftMonitor.setCurrentStepResult(CraftsMonitorResultCode.add_liquid_column.getDescription() + Arrays.toString(finishColumns.toArray()));
craftMonitorService.saveMonitor(craftMonitor);
/*工艺监控结束*/
/*获取配置信息*/
log.info("工艺{},获取配置信息", heatModuleCode);
deviceStateService.getDeviceState().getSolutionModule().setPumping(true);
Double transferModuleXPickTrayMoveDistance = devicePositionService.getPosition(DevicePositionCode.transferModuleXPickTrayMoveDistance).getDistance();//获取转运模块X轴拿取托盘进出卡槽移动距离
Point3D liquidAreaTrayPoint3D = devicePositionService.getPosition(DevicePositionCode.liquidAreaTrayPoint).getPoint3D();//获取加液时托盘位置点
@ -340,7 +330,6 @@ public class CraftsStepService {
}
log.info("工艺{},申请转运模组并等待", heatModuleCode);
transferModuleService.requestTransferModule(CraftsTransferTypeCode.move_thick);//申请转运模组并等待
deviceStateService.getDeviceState().getTrayByHeatModuleCode(heatModuleCode).setUseArm(true);//使用机械臂标志
@ -348,32 +337,28 @@ public class CraftsStepService {
/*移动至加液区*/
boolean heatTrayExist = deviceSensorService.getTrayStateByHeatModuleCode(heatModuleCode);//获取加热区托盘
Assert.isTrue(heatTrayExist, () -> new AppException(ResultCode.CRAFT_HEAT_NO_TRAY));//目标加热区无托盘
log.info("工艺{},加热区存在托盘", heatModuleCode);
log.info("工艺{},机械臂移动至加热区", heatModuleCode);
transferModuleService.transferMove(liquidAreaTrayPoint3D);//移动至加液时托盘位置点
boolean clawTrayExist = deviceSensorService.getSensorStatus(DeviceSensorCode.CLAW_TRAY_EXIST);//获取传感器状态
Assert.isTrue(!clawTrayExist, () -> new AppException(ResultCode.CRAFT_SOLUTION_EXIST_TRAY));//加液区存在托盘
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "机械臂移动至加热区", heatModuleCode.name()));
log.info("工艺{},将X轴移动至目标加热模块托盘夹取点 + 进出卡槽移动距离", heatModuleCode);
transferModuleService.transferXMove(heatModuleTrayClawPoint3D.getX() + transferModuleXPickTrayMoveDistance);//将X轴移动至目标加热模块托盘夹取点 + 进出卡槽移动距离
log.info("工艺{},Z轴下降至夹取点", heatModuleCode);
heatTrayExist = deviceSensorService.getTrayStateByHeatModuleCode(heatModuleCode);//获取加热区托盘
Assert.isTrue(heatTrayExist, () -> new AppException(ResultCode.CRAFT_HEAT_NO_TRAY));//目标加热区无托盘
transferModuleService.transferZMove(heatModuleTrayClawPoint3D.getZ());//Z轴下降至夹取点
log.info("工艺{},X轴进入卡槽", heatModuleCode);
transferModuleService.transferXMoveBy(-transferModuleXPickTrayMoveDistance);//X轴进入卡槽
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setTrayStatus(false);//加热区托盘状态
deviceStateService.getDeviceState().getTrayByHeatModuleCode(heatModuleCode).setInHeatModule(false);//托盘状态
log.info("工艺{},Z轴抬升至最高", heatModuleCode);
transferModuleService.transferZMoveZero();//Z轴抬升至最高
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "机械臂移动至加液区", DevicePositionCode.liquidAreaTrayPoint.name()));
log.info("工艺{},移动至加液时托盘位置点", heatModuleCode);
transferModuleService.transferMove(liquidAreaTrayPoint3D);//移动至加液时托盘位置点
deviceStateService.getDeviceState().getTrayByHeatModuleCode(heatModuleCode).setInSolutionPositon(true);//托盘状态
boolean clawTrayExist = deviceSensorService.getSensorStatus(DeviceSensorCode.CLAW_TRAY_EXIST);//获取传感器状态
clawTrayExist = deviceSensorService.getSensorStatus(DeviceSensorCode.CLAW_TRAY_EXIST);//获取传感器状态
Assert.isTrue(clawTrayExist, () -> new AppException(ResultCode.TARGET_HEAT_MODULE_NO_TRAY));//加液区无托盘
/*移动至加液区结束*/
/*开始抽液*/
log.info("工艺{},开始抽液", heatModuleCode);
solutionModuleService.liquidValveSwitch(SolutionCode.waste);//电磁阀转换到废液
solutionModuleService.liquidPumpSetSpeed(pumpReduceSpeed);//设置泵的抽取转速
List<Integer> reduceColumns = new ArrayList<>();
@ -387,14 +372,10 @@ public class CraftsStepService {
for (int i = 0; i < reduceColumns.size(); i++) {
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "移动加液机械臂到指定试管", i));
double distance = Math.abs(reduceColumns.get(i) - 5) * trayTubeHorizontalSpacingDistance;//机械臂右移距离
log.info("工艺{},机械臂移动到试管位置{}", heatModuleCode, i);
transferModuleService.transferXMove(liquidAreaTrayPoint3D.getX() + distance);//机械臂移动到试管位置
log.info("工艺{},加液机械臂下降", heatModuleCode);
solutionModuleService.solutionMotorMove(solutionModuleMotorDownInTubeExtPositon + height);//加液机械臂下降
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "抽取溶液", addLiquidDistance));
log.info("工艺{},加液", heatModuleCode);
solutionModuleService.liquidPumpMove(-reduceDistance);//加液 position
log.info("工艺{},加液机械臂上升", heatModuleCode);
solutionModuleService.solutionMotorMoveZero();//加液机械臂上升
}
solutionModuleService.liquidPumpMove(-backFlowDistance);//预充
@ -406,34 +387,25 @@ public class CraftsStepService {
/*预充开始*/
boolean feedTrayExist = deviceSensorService.getSensorStatus(DeviceSensorCode.LIQUID_TRAY_EXIST);//获取传感器状态
Assert.isTrue(!feedTrayExist, () -> new AppException(ResultCode.FEED_AREA_EXIST_TRAY));//上料区有托盘
log.info("工艺{},预充开始", heatModuleCode);
log.info("工艺{},加液机械臂上升", heatModuleCode);
solutionModuleService.solutionMotorMoveZero();//加液机械臂上升
transferModuleService.transferXMove(heatArea1TrayClawPoint.getX());//转运模块移动至加热位1
feedTrayExist = deviceSensorService.getSensorStatus(DeviceSensorCode.LIQUID_TRAY_EXIST);//获取传感器状态
Assert.isTrue(!feedTrayExist, () -> new AppException(ResultCode.FEED_AREA_EXIST_TRAY));//上料区有托盘
solutionModuleService.solutionMotorMove(liquidAreaPreFillPoint);//加液机械臂下降至至预充点位
log.info("工艺{},电磁阀对应通道打开", heatModuleCode);
solutionModuleService.liquidValveSwitch(SolutionCode.waste);//电磁阀对应通道打开
solutionModuleService.liquidPumpSetSpeed(pumpNormalSpeed);//设置泵的正常转速
log.info("工艺{},排空", heatModuleCode);
solutionModuleService.liquidPumpMove(-drainDistance);//排空
log.info("工艺{},电磁阀对应通道打开", heatModuleCode);
solutionModuleService.liquidValveSwitchByChannel(channel);//电磁阀对应通道打开
log.info("工艺{},预充", heatModuleCode);
solutionModuleService.liquidPumpMove(preFillDistance);//预充
solutionModuleService.liquidPumpMove(-backFlowDistance);//预充
log.info("工艺{},加液机械臂上升", heatModuleCode);
solutionModuleService.solutionMotorMoveZero();//加液机械臂上升
/*预充结束*/
/*移动至加液区*/
log.info("工艺{},移动至加液区", heatModuleCode);
transferModuleService.transferMove(liquidAreaTrayPoint3D);//移动至加液至托盘位置点
/*移动至加液区*/
/*开始加液*/
log.info("工艺{},开始加液", heatModuleCode);
List<Integer> addColumns;
if (jsonArray != null) {
addColumns = new ArrayList<>();
@ -447,14 +419,10 @@ public class CraftsStepService {
for (int i = 0; i < addColumns.size(); i++) {
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "移动加液机械臂到指定试管", addColumns.get(i)));
double distance = Math.abs(addColumns.get(i) - 5) * trayTubeHorizontalSpacingDistance;//机械臂右移距离
log.info("工艺{},机械臂移动到试管位置{}", heatModuleCode, i);
transferModuleService.transferXMove(liquidAreaTrayPoint3D.getX() + distance);//机械臂移动到试管位置
log.info("工艺{},加液机械臂下降", heatModuleCode);
solutionModuleService.solutionMotorMove(solutionModuleMotorDownInTubeAddPositon);//加液机械臂下降
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "添加溶液", addLiquidDistance));
log.info("工艺{},加液", heatModuleCode);
solutionModuleService.liquidPumpMove(addLiquidDistance);//加液 position
log.info("工艺{},加液机械臂上升", heatModuleCode);
solutionModuleService.solutionMotorMoveZero();//加液机械臂上升
/*工艺监控开始*/
finishColumns.add(i);
@ -468,19 +436,14 @@ public class CraftsStepService {
/*结束加液*/
/*移动至加热区*/
log.info("工艺{},移动至加热区", heatModuleCode);
boolean heatModuleTrayExist = deviceSensorService.getTrayStateByHeatModuleCode(heatModuleCode);//目标加热模块有无托盘
Assert.isTrue(!heatModuleTrayExist, () -> new AppException(ResultCode.CRAFT_HEAT_EXIST_TRAY));//提示被占用
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "机械臂移动至加热区", heatModuleCode));
log.info("工艺{},加液机械臂上升", heatModuleCode);
solutionModuleService.solutionMotorMoveZero();//加液机械臂上升
log.info("工艺{},将X轴移动至目标加热模块托盘夹取点", heatModuleCode);
transferModuleService.transferXMove(heatModuleTrayClawPoint3D.getX());//将X轴移动至目标加热模块托盘夹取点
log.info("工艺{},Z轴下降至夹取点", heatModuleCode);
heatModuleTrayExist = deviceSensorService.getTrayStateByHeatModuleCode(heatModuleCode);//目标加热模块有托盘
Assert.isTrue(!heatModuleTrayExist, () -> new AppException(ResultCode.CRAFT_HEAT_EXIST_TRAY));//提示被占用
transferModuleService.transferZMove(heatModuleTrayClawPoint3D.getZ());//Z轴下降至夹取点，使托盘落入石墨加热盘
log.info("工艺{},X轴移出卡槽", heatModuleCode);
transferModuleService.transferXMoveBy(transferModuleXPickTrayMoveDistance);//X轴移出卡槽
transferModuleService.transferZMoveZero();//Z轴抬升至最高
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setTrayStatus(true);//加热区托盘状态
@ -515,15 +478,12 @@ public class CraftsStepService {
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setHeatingType(HeatingType.heating); //设置加热区状态 加热中
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setTargetTemperature(temperature);//将加热温度设定为目标温度
log.info("工艺{},开始加热", heatModuleCode);
heatModuleService.fanClose(heatModuleCode);//关闭风扇
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setFanOpen(false); //设置加热区风扇关闭
heatModuleService.heatRodOpen(heatModuleCode, temperature);//打开加热棒
while (!heatIsSuitable(heatModuleCode, temperature)) {//判断温度是否到达
TimeUnit.SECONDS.sleep(1);
}
log.info("工艺{},温度达到", heatModuleCode);
log.info("工艺{},恒温时间", time);
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "温度达到", temperature));
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setHeatingType(HeatingType.constant); //恒温中
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setStartHeatTime(LocalDateTime.now());//开始加热时间
@ -531,10 +491,7 @@ public class CraftsStepService {
int clock = 0;
int cycle = time / 60;
int seconds = time % 60;
log.info("工艺{},恒温时间分钟:", cycle);
log.info("工艺{},恒温时间秒数:", seconds);
while (cycle > 0) {
log.info("工艺,恒温第{}分:", cycle);
TimeUnit.SECONDS.sleep(60);
cycle--;
clock = clock + 60;
@ -545,11 +502,9 @@ public class CraftsStepService {
/*保存到工艺监控*/
}
TimeUnit.SECONDS.sleep(seconds);
log.info("工艺,恒温结束:");
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setStartHeatTime(null);//开始加热时间
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setTargetTime(null);//加热器目标加热时间
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setHeatingType(HeatingType.finish); //加热完成
log.info("工艺{},加热结束", heatModuleCode);
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "加热结束，持续时间", time));
return true;
} catch (Exception e) {
@ -564,7 +519,6 @@ public class CraftsStepService {
* */
public boolean clean(HeatModuleCode heatModuleCode, JSONObject params, CraftMonitor craftMonitor) throws Exception {
try {
log.info("工艺{},----------------------------------清洗---------------------------------------------", heatModuleCode);
/*关门*/
doorClose();
/*保存到监控开始*/
@ -604,23 +558,20 @@ public class CraftsStepService {
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "机械臂移动至加热区", heatModuleTrayClawPoint3D));
/*获取参数结束*/
log.info("工艺{},申请转运模组并等待", heatModuleCode);
transferModuleService.requestTransferModule(CraftsTransferTypeCode.move_thick);//申请转运模组并等待
deviceStateService.getDeviceState().getTrayByHeatModuleCode(heatModuleCode).setUseArm(true);//使用机械臂标志
log.info("工艺{},加液机械臂上升", heatModuleCode);
solutionModuleService.solutionMotorMoveZero();//加液机械臂上升
log.info("工艺{},将X轴移动至目标加热模块托盘夹取点 + 进出卡槽移动距离", heatModuleCode);
transferModuleService.transferMove(liquidAreaTrayPoint3D);//移动至加液时托盘位置点
boolean clawTrayExist = deviceSensorService.getSensorStatus(DeviceSensorCode.CLAW_TRAY_EXIST);//获取传感器状态
Assert.isTrue(!clawTrayExist, () -> new AppException(ResultCode.CRAFT_SOLUTION_EXIST_TRAY));//加液区存在托盘
transferModuleService.transferXMove(heatModuleTrayClawPoint3D.getX() + transferModuleXPickTrayMoveDistance);//将X轴移动至目标加热模块托盘夹取点 + 进出卡槽移动距离
log.info("工艺{},Z轴下降至夹取点", heatModuleCode);
heatModuleTrayExist = deviceSensorService.getTrayStateByHeatModuleCode(heatModuleCode);//目标加热模块有无托盘
Assert.isTrue(heatModuleTrayExist, () -> new AppException(ResultCode.CRAFT_TARGET_HEAT_NO_TRAY));//提示工艺加热区无托盘
transferModuleService.transferZMove(heatModuleTrayClawPoint3D.getZ());//Z轴下降至夹取点
log.info("工艺{},X轴进入卡槽", heatModuleCode);
transferModuleService.transferXMoveBy(-transferModuleXPickTrayMoveDistance);//X轴进入卡槽
log.info("工艺{},Z轴抬升至最高", heatModuleCode);
transferModuleService.transferZMoveZero();//Z轴抬升至最高
log.info("工艺{},机械臂移动至加液区", heatModuleCode);
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "机械臂移动至加液区", liquidAreaTrayPoint3D));
transferModuleService.transferMove(liquidAreaTrayPoint3D);//移动至加液时托盘位置点
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setTrayStatus(false);//加热区托盘状态
@ -644,15 +595,10 @@ public class CraftsStepService {
for (int j = 0; j < columns.size(); j++) {
double distance = Math.abs(columns.get(j) - 5) * trayTubeHorizontalSpacingDistance;//x轴移动距离
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "机械臂移动到试管位置", j));
log.info("工艺{},机械臂移动到试管位置", heatModuleCode);
transferModuleService.transferXMove(liquidAreaTrayPoint3D.getX() + distance);//机械臂移动到试管位置
log.info("工艺{},加液模块下降进入试管抽取位置", heatModuleCode);
solutionModuleService.solutionMotorMove(solutionModuleMotorDownInTubeExtPositon + height);//加液模块下降进入试管抽取位置
log.info("工艺{},电磁阀对应通道打开", heatModuleCode);
log.info("工艺{},蠕动泵抽水", heatModuleCode);
solutionModuleService.liquidPumpMove(-reduceThickDistance);//蠕动泵抽浓硝酸
log.info("工艺{},加液模块上升至最高，移出试管", heatModuleCode);
solutionModuleService.solutionMotorMoveZero();//加液模块上升至最高，移出试管
}
/*抽液结束*/
@ -667,7 +613,6 @@ public class CraftsStepService {
/*预充开始*/
boolean feedTrayExist = deviceSensorService.getSensorStatus(DeviceSensorCode.LIQUID_TRAY_EXIST);//获取传感器状态
Assert.isTrue(!feedTrayExist, () -> new AppException(ResultCode.FEED_AREA_EXIST_TRAY));//上料区有托盘
log.info("工艺{},清洗-预充开始", heatModuleCode);
solutionModuleService.solutionMotorMoveZero();//加液机械臂上升
transferModuleService.transferXMove(heatArea1TrayClawPoint.getX());//转运模块移动至加热位1
feedTrayExist = deviceSensorService.getSensorStatus(DeviceSensorCode.LIQUID_TRAY_EXIST);//获取传感器状态
@ -679,26 +624,19 @@ public class CraftsStepService {
solutionModuleService.liquidPumpMove(preFillDistance);//预充
solutionModuleService.liquidPumpMove(-backFlowDistance);//防滴落
solutionModuleService.solutionMotorMoveZero();//加液机械臂上升
log.info("工艺{},清洗开始", heatModuleCode);
transferModuleService.transferMove(liquidAreaTrayPoint3D);//移动至加液时托盘位置点
/*预充结束*/
/*加*/
log.info("工艺{},电磁阀蒸馏水通道打开", heatModuleCode);
solutionModuleService.liquidValveSwitch(SolutionCode.water);//电磁阀对应通道打开
for (int j = 0; j < columns.size(); j++) {
double distance = Math.abs(columns.get(j) - 5) * trayTubeHorizontalSpacingDistance;//x轴移动距离
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "机械臂移动到试管位置", j));
log.info("工艺{},机械臂移动到试管位置", heatModuleCode);
transferModuleService.transferXMove(liquidAreaTrayPoint3D.getX() + distance);//机械臂移动到试管位置
log.info("工艺{},加液模块下降进入试管抽取位置", heatModuleCode);
solutionModuleService.solutionMotorMove(solutionModuleMotorDownInTubeAddPositon);//加液模块下降进入试管加液位置
log.info("工艺{},蠕动泵加水", heatModuleCode);
solutionModuleService.liquidPumpMove(cleanWaterDistance);//蠕动泵加水
log.info("工艺{},加液模块上升至最高，移出试管", heatModuleCode);
solutionModuleService.solutionMotorMoveZero();//加液模块上升至最高，移出试管
}
solutionModuleService.liquidPumpMove(-backFlowDistance);//防滴落
log.info("工艺{},电磁阀废液通道打开", heatModuleCode);
TimeUnit.SECONDS.sleep(1);//当前线程休眠1秒
/*抽*/
solutionModuleService.liquidValveSwitch(SolutionCode.waste);//电磁阀对应通道打开
@ -706,15 +644,10 @@ public class CraftsStepService {
for (int j = 0; j < columns.size(); j++) {
double distance = Math.abs(columns.get(j) - 5) * trayTubeHorizontalSpacingDistance;//x轴移动距离
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "机械臂移动到试管位置", j));
log.info("工艺{},机械臂移动到试管位置", heatModuleCode);
transferModuleService.transferXMove(liquidAreaTrayPoint3D.getX() + distance);//机械臂移动到试管位置
log.info("工艺{},加液模块下降进入试管抽取位置", heatModuleCode);
solutionModuleService.solutionMotorMove(solutionModuleMotorDownInTubeExtPositon + height);//加液模块下降进入试管抽取位置
log.info("工艺{},电磁阀对应通道打开", heatModuleCode);
log.info("工艺{},蠕动泵抽水", heatModuleCode);
solutionModuleService.liquidPumpMove(-reduceWaterDistance);//抽水
log.info("工艺{},加液模块上升至最高，移出试管", heatModuleCode);
solutionModuleService.solutionMotorMoveZero();//加液模块上升至最高，移出试管
}
craftMonitor.setDeviceState(JSONUtil.toJsonStr(deviceStateService.getDeviceState()));
@ -724,22 +657,17 @@ public class CraftsStepService {
}
/*清洗结束*/
log.info("工艺{},将X轴移动至目标加热模块托盘夹取点", heatModuleCode);
transferModuleService.transferXMove(heatModuleTrayClawPoint3D.getX());//将X轴移动至目标加热模块托盘夹取点
log.info("工艺{},Z轴下降至夹取点，使托盘落入石墨加热盘", heatModuleCode);
heatModuleTrayExist = deviceSensorService.getTrayStateByHeatModuleCode(heatModuleCode);//目标加热模块有无托盘
Assert.isTrue(!heatModuleTrayExist, () -> new AppException(ResultCode.CRAFT_HEAT_EXIST_TRAY));//提示工艺加热区被占用
transferModuleService.transferZMove(heatModuleTrayClawPoint3D.getZ());//Z轴下降至夹取点，使托盘落入石墨加热盘
log.info("工艺{},X轴移出卡槽", heatModuleCode);
transferModuleService.transferXMoveBy(transferModuleXPickTrayMoveDistance);//X轴移出卡槽
log.info("工艺{},Z轴抬升至最高", heatModuleCode);
transferModuleService.transferZMoveZero();//Z轴抬升至最高
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setTrayStatus(true);//加热区托盘状态
deviceStateService.getDeviceState().getTrayByHeatModuleCode(heatModuleCode).setInHeatModule(true);//托盘状态
deviceStateService.getDeviceState().getSolutionModule().setPumping(false);//正在加液
deviceStateService.getDeviceState().getTrayByHeatModuleCode(heatModuleCode).setInSolutionPositon(false);//托盘状态
doorAble();//开门
log.info("工艺{},释放转运模组", heatModuleCode);
transferModuleService.releaseTransferModule();//释放转运模组
return true;
} catch (Exception e) {
@ -770,9 +698,7 @@ public class CraftsStepService {
heatModuleService.heatRodOpen(heatModuleCode, temperature);//打开加热棒
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setHeatingType(HeatingType.heating); //设置加热区状态 烘干中
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setTargetTemperature(temperature);//将加热温度设定为目标温度
log.info("工艺{},开始加热", heatModuleCode);
heatModuleService.heatRodOpen(heatModuleCode, temperature);
log.info("工艺{},判断当前温度是否在设置温度范围内", heatModuleCode);
while (!heatIsSuitable(heatModuleCode, temperature)) { //判断当前温度是否在设置温度范围内
TimeUnit.SECONDS.sleep(1);
}
@ -790,9 +716,7 @@ public class CraftsStepService {
craftMonitor.setCurrentStepResult(CraftsMonitorResultCode.heat_time.getDescription() + ":" + clock / 60);
craftMonitorService.saveMonitor(craftMonitor);
}
log.info("工艺{},恒温中", heatModuleCode);
TimeUnit.SECONDS.sleep(seconds);
log.info("工艺{},关闭加热棒", heatModuleCode);
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "关闭加热棒", ""));
heatModuleService.heatRodClose(heatModuleCode);//关闭加热棒
CompletableFuture.runAsync(() -> {
@ -835,35 +759,22 @@ public class CraftsStepService {
while (deviceSensorService.getTrayStateByHeatModuleCode(HeatModuleCode.heat_module_04)) {//判断退火区是否被占用
TimeUnit.SECONDS.sleep(1);//等待1秒
}
log.info("工艺{},机械臂移动至加热区", heatModuleCode);
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "机械臂移动至加热区", heatModuleCode));
log.info("工艺{},申请使用转运模块", heatModuleCode);
transferModuleService.requestTransferModule(CraftsTransferTypeCode.move_anneal);//申请使用转运模块
log.info("工艺{},加液机械臂上升", heatModuleCode);
solutionModuleService.solutionMotorMoveZero();//加液机械臂上升
log.info("工艺{},将X轴移动至目标加热模块托盘夹取点", heatModuleCode);
transferModuleService.transferXMove(heatModuleTrayClawPoint3D.getX() + transferModuleXPickTrayMoveDistance);//将X轴移动至目标加热模块托盘夹取点
log.info("工艺{},Z轴下降至夹取点，使托盘落入石墨加热盘", heatModuleCode);
heatModuleTrayExist = deviceSensorService.getTrayStateByHeatModuleCode(heatModuleCode);
Assert.isTrue(heatModuleTrayExist, () -> new AppException(ResultCode.CRAFT_TARGET_HEAT_NO_TRAY));//提示加热模块无托盘
transferModuleService.transferZMove(heatModuleTrayClawPoint3D.getZ());//Z轴下降至夹取点，使托盘落入石墨加热盘
log.info("工艺{},X轴移出入槽", heatModuleCode);
transferModuleService.transferXMoveBy(-transferModuleXPickTrayMoveDistance);//X轴移出入槽
log.info("工艺{},Z轴抬升至最高", heatModuleCode);
transferModuleService.transferZMoveZero();//Z轴抬升至最高
log.info("工艺{},机械臂移动至退火区", heatModuleCode);
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "机械臂移动至退火区", HeatModuleCode.heat_module_04));
log.info("工艺{},将X轴移动至退火热模块托盘夹取点", heatModuleCode);
transferModuleService.transferXMove(annealTrayClawPoint3D.getX());//将X轴移动至退火热模块托盘夹取点
log.info("工艺{},Z轴下降至夹取点，使托盘落入石墨加热盘", heatModuleCode);
boolean heatModule04TrayExist = deviceSensorService.getTrayStateByHeatModuleCode(HeatModuleCode.heat_module_04);
Assert.isTrue(!heatModule04TrayExist, () -> new AppException(ResultCode.CRAFT_HEAT_EXIST_TRAY));//提示退火模块存在托盘
transferModuleService.transferZMove(annealTrayClawPoint3D.getZ());//Z轴下降至夹取点，使托盘落入石墨加热盘
log.info("工艺{},X轴移出卡槽", heatModuleCode);
transferModuleService.transferXMoveBy(transferModuleXPickTrayMoveDistance);//X轴移出卡槽
log.info("工艺{},Z轴抬升至最高", heatModuleCode);
transferModuleService.transferZMoveZero();//Z轴抬升至最高
log.info("工艺{},释放转运模组", heatModuleCode);
transferModuleService.releaseTransferModule();//释放转运模组
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setTrayStatus(false);//加热区托盘状态
deviceStateService.getDeviceState().getTrayByHeatModuleCode(heatModuleCode).setInHeatModule(false);//托盘状态
@ -873,7 +784,6 @@ public class CraftsStepService {
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(HeatModuleCode.heat_module_04.name(), "打开加热棒", temperature));
deviceStateService.getDeviceState().getHeatModuleByCode(HeatModuleCode.heat_module_04).setHeatingType(HeatingType.heating); //设置加热区状态 加热中
deviceStateService.getDeviceState().getHeatModuleByCode(HeatModuleCode.heat_module_04).setTargetTemperature(temperature);//将加热温度设定为目标温度
log.info("工艺{},开始加热", heatModuleCode);
heatModuleService.heatRodOpen(HeatModuleCode.heat_module_04, temperature);//打开加热棒
//判断当前温度是否在设置温度范围内
while (!heatIsSuitable(HeatModuleCode.heat_module_04, temperature)) {
@ -893,39 +803,26 @@ public class CraftsStepService {
craftMonitor.setCurrentStepResult(CraftsMonitorResultCode.heat_time.getDescription() + ":" + clock / 60);
craftMonitorService.saveMonitor(craftMonitor);
}
log.info("工艺{},恒温中", HeatModuleCode.heat_module_04);
TimeUnit.SECONDS.sleep(seconds);
deviceStateService.getDeviceState().getHeatModuleByCode(HeatModuleCode.heat_module_04).setStartHeatTime(null);//开始加热时间
deviceStateService.getDeviceState().getHeatModuleByCode(HeatModuleCode.heat_module_04).setTargetTime(null);//加热器目标加热时间
log.info("工艺{},加热完毕", heatModuleCode);
log.info("工艺{},获取转运模组锁", heatModuleCode);
transferModuleService.requestTransferModule(CraftsTransferTypeCode.move_heat);//获取转运模组锁
deviceStateService.getDeviceState().getTrayByHeatModuleCode(heatModuleCode).setUseArm(true);//使用机械臂标志
log.info("工艺{},Z轴抬升至最高", heatModuleCode);
transferModuleService.transferZMoveZero();//Z轴抬升至最高
log.info("工艺{},将X轴移动至目标加热模块托盘夹取点", heatModuleCode);
transferModuleService.transferXMove(annealTrayClawPoint3D.getX() + transferModuleXPickTrayMoveDistance);//将X轴移动至目标退火模块托盘夹取点
log.info("工艺{},Z轴下降至夹取点，使托盘落入石墨加热盘", heatModuleCode);
heatModule04TrayExist = deviceSensorService.getTrayStateByHeatModuleCode(HeatModuleCode.heat_module_04);
Assert.isTrue(heatModule04TrayExist, () -> new AppException(ResultCode.CRAFT_HEAT_NO_TRAY));//提示退火区无托盘
transferModuleService.transferZMove(annealTrayClawPoint3D.getZ());//Z轴下降至夹取点，使托盘落入石墨加热盘
log.info("工艺{},X移入卡槽", heatModuleCode);
transferModuleService.transferXMoveBy(-transferModuleXPickTrayMoveDistance);//X移入卡槽
log.info("工艺{},Z轴抬升至最高", heatModuleCode);
transferModuleService.transferZMoveZero();//Z轴抬升至最高
log.info("工艺{},将X轴移动至目标加热模块托盘夹取点", heatModuleCode);
transferModuleService.transferXMove(heatModuleTrayClawPoint3D.getX());//将X轴移动至目标加热模块托盘夹取点
log.info("工艺{},Z轴下降至夹取点，使托盘落入石墨加热盘", heatModuleCode);
heatModuleTrayExist = deviceSensorService.getTrayStateByHeatModuleCode(heatModuleCode);
Assert.isTrue(!heatModuleTrayExist, () -> new AppException(ResultCode.CRAFT_HEAT_EXIST_TRAY));//提示加热模块存在托盘
transferModuleService.transferZMove(heatModuleTrayClawPoint3D.getZ());//Z轴下降至夹取点，使托盘落入石墨加热盘
log.info("工艺{},X轴移出卡槽", heatModuleCode);
transferModuleService.transferXMoveBy(transferModuleXPickTrayMoveDistance);//X轴移出卡槽
log.info("工艺{},Z轴抬升至最高", heatModuleCode);
transferModuleService.transferZMoveZero();//Z轴抬升至最高
log.info("工艺{},转运模组释放", heatModuleCode);
transferModuleService.releaseTransferModule();//释放转运模组
heatModuleService.fanClose(heatModuleCode);//关闭风扇
deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).setFanOpen(false); //设置加热区风扇关闭
@ -944,21 +841,12 @@ public class CraftsStepService {
/*
* 检测加热区升温度是否合适
* */
public boolean heatIsSuitable(HeatModuleCode heatModuleCode, Double temperature) throws Exception {
public boolean heatIsSuitable(HeatModuleCode heatModuleCode, Double temperature){
double currentTemperature = deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).getTemperature();
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "加热区温度", currentTemperature));
return currentTemperature > (temperature - 3);
}
/*
* 检测加热区降温温度是否合适
* */
public boolean coldIsSuitable(HeatModuleCode heatModuleCode, Double temperature) throws Exception {
double currentTemperature = deviceStateService.getDeviceState().getHeatModuleByCode(heatModuleCode).getTemperature();
log.info("工艺{},当前温度{}", heatModuleCode, currentTemperature);
webSocketService.pushCraftsDebug(CraftsDebugGenerator.generateJson(heatModuleCode.toString(), "加热区温度", currentTemperature));
return currentTemperature < (temperature + 3);
}
/**
* 工艺执行完毕
@ -968,6 +856,8 @@ public class CraftsStepService {
TimeUnit.SECONDS.sleep(2);//当前线程休眠2秒
deviceLightSoundService.closeBeep();
craftMonitorService.remove(new LambdaQueryWrapper<CraftMonitor>().eq(CraftMonitor::getHeatId, heatModuleCode));
List<TrayState> trayList = deviceStateService.getDeviceState().getTrays();
trayList.removeIf((tray) -> tray.getHeatModuleCode() != null && tray.getHeatModuleCode().equals(heatModuleCode));
}

11
src/main/java/com/iflytop/sgs/app/service/device/module/TransferModuleService.java
View File

@ -31,7 +31,6 @@ public class TransferModuleService {
private final BlockingQueue<Thread> thickQueue = new ArrayBlockingQueue<>(3);
private final BlockingQueue<Thread> annealQueue = new ArrayBlockingQueue<>(3);
private final BlockingQueue<Thread> heatQueue = new ArrayBlockingQueue<>(1);
private final BlockingQueue<Thread> feedQueue = new ArrayBlockingQueue<>(3);
/**
* 申请使用转运模块。
@ -53,9 +52,6 @@ public class TransferModuleService {
deviceStateService.getDeviceState().getTransferModule().setIdle(false);
return true;
}
case move_feed:
feedQueue.add(current);
break;
case move_heat:
heatQueue.add(current);
break;
@ -82,9 +78,7 @@ public class TransferModuleService {
} else {
// 模块空闲时，再判断当前线程是否是“四个队列”里优先级最高且队头的那个
Thread head = null;
if (!feedQueue.isEmpty()) {
head = feedQueue.peek();
} else if (!thinQueue.isEmpty()) {
if (!thinQueue.isEmpty()) {
head = thinQueue.peek();
} else if (!heatQueue.isEmpty()) {
head = heatQueue.peek();
@ -139,9 +133,6 @@ public class TransferModuleService {
*/
private void removeCurrentFromQueue(CraftsTransferTypeCode type, Thread current) {
switch (type) {
case move_feed:
feedQueue.remove(current);
break;
case move_heat:
heatQueue.remove(current);
break;

2
src/main/java/com/iflytop/sgs/common/enums/CraftsTransferTypeCode.java
View File

@ -11,7 +11,7 @@ public enum CraftsTransferTypeCode {
move_thin("移动至加液区加稀硝酸"),
move_anneal("移动至退火区"),
move_heat("移动至加热区"),
move_feed("移动至上料区"),
//move_feed("移动至上料区"),
move_by_manual("手动指令操作"),;
private String description;

8
src/main/java/com/iflytop/sgs/common/enums/SystemConfigCode.java
View File

@ -29,10 +29,10 @@ public enum SystemConfigCode {
fan_start_keep_time("烘干后风扇开启开始降温的时间(秒)"),
pump_reduce_speed("蠕动泵抽液速度 0-300"),
pump_normal_speed("蠕动泵正常速度 标准值300"),
anneal_temperature("退火温度 标准值400"),
dry_temperature("烘干温度 标准值135"),
heat_temperature("加热温度 标准值100"),
needle_drop_height("抽液针下降高度 标准55")
anneal_temperature("最高退火温度 标准值450"),
dry_temperature("最高烘干温度 标准值135"),
heat_temperature("最高加热温度 标准值100"),
needle_drop_height("最大抽液针下降高度 标准55")
;
private final String description;

12
src/main/java/com/iflytop/sgs/common/enums/data/CraftsPreHeatType.java
View File

@ -0,0 +1,12 @@
package com.iflytop.sgs.common.enums.data;
import lombok.Getter;
/**
* 工艺预热加热位选择
*/
@Getter
public enum CraftsPreHeatType {
heat,
anneal,
}

3
src/main/java/com/iflytop/sgs/common/result/ResultCode.java
View File

@ -45,7 +45,8 @@ public enum ResultCode implements IResultCode, Serializable {
CRAFT_SOLUTION_NO_TRAY("4008", "工艺 加液区无托盘"),
HEAT_TEMPERATURE_NULL("4009", "请先配置该加热区温度"),
CRAFT_HEAT_EXIST_TRAY("4010", "工艺 加热区已经存在托盘"),
CRAFT_HEAT_NO_TRAY("4010", "工艺 加热区无存在托盘"),
CRAFT_HEAT_NO_TRAY("4011", "工艺 加热区无存在托盘"),
CRAFT_SOLUTION_EXIST_TRAY("4012", "工艺 夹爪存在无托盘"),
//============================ 5xxx：系统 & 第三方 ============================
SYSTEM_ERROR("5000", "系统内部错误"),
SERVICE_UNAVAILABLE("5001", "服务暂不可用"),

Write Preview
Loading…
Cancel
Save