package com.zy.asrs.controller;
|
|
import com.baomidou.mybatisplus.mapper.EntityWrapper;
|
import com.core.annotations.ManagerAuth;
|
import com.core.common.BaseRes;
|
import com.core.common.Cools;
|
import com.core.common.R;
|
import com.core.exception.CoolException;
|
import com.zy.asrs.domain.enums.CrnStatusType;
|
import com.zy.asrs.domain.param.SteModeParam;
|
import com.zy.asrs.domain.param.SteOperatorParam;
|
import com.zy.asrs.domain.vo.SteDataVo;
|
import com.zy.asrs.domain.vo.SteMsgTableVo;
|
import com.zy.asrs.domain.vo.SteSensorDataVo;
|
import com.zy.asrs.domain.vo.SteStateTableVo;
|
import com.zy.asrs.entity.BasSte;
|
import com.zy.asrs.entity.WrkMast;
|
import com.zy.asrs.service.BasSteService;
|
import com.zy.asrs.service.WrkMastService;
|
import com.zy.core.cache.MessageQueue;
|
import com.zy.core.cache.OutputQueue;
|
import com.zy.core.cache.SlaveConnection;
|
import com.zy.core.enums.SlaveType;
|
import com.zy.core.enums.SteTaskModeType;
|
import com.zy.core.model.SteSlave;
|
import com.zy.core.model.Task;
|
import com.zy.core.model.command.SteCommand;
|
import com.zy.core.model.protocol.SteProtocol;
|
import com.zy.core.properties.SlaveProperties;
|
import com.zy.core.properties.SystemProperties;
|
import com.zy.core.thread.SteThread;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.web.bind.annotation.*;
|
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.List;
|
|
/**
|
* 穿梭车接口
|
* Created by vincent on 2022/3/14
|
*/
|
@Slf4j
|
@RestController
|
@RequestMapping("/ste")
|
public class SteController {
|
|
@Autowired
|
private SlaveProperties slaveProperties;
|
@Autowired
|
private BasSteService basSteService;
|
@Autowired
|
private WrkMastService wrkMastService;
|
|
@PostMapping("/table/ste/state")
|
@ManagerAuth(memo = "穿梭车信息表")
|
public R steStateTable(){
|
List<SteStateTableVo> list = new ArrayList<>();
|
List<BasSte> stes = basSteService.selectList(new EntityWrapper<BasSte>().orderBy("ste_no"));
|
for (BasSte basSte : stes) {
|
// 表格行
|
SteStateTableVo vo = new SteStateTableVo();
|
vo.setSteNo(basSte.getSteNo()); // 穿梭车号
|
list.add(vo);
|
// 获取穿梭车信息
|
SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, basSte.getSteNo());
|
if (steThread == null) {
|
continue;
|
}
|
SteProtocol steProtocol = steThread.getSteProtocol();
|
if (steProtocol == null) {
|
continue;
|
}
|
vo.setTaskNo(steProtocol.getTaskNo().intValue()); // 任务号
|
vo.setStatusVal(steProtocol.getMode().intValue()); // 在线状态
|
vo.setStatusType(steProtocol.mode == 0 ? "离线" : "在线"); // 模式状态
|
if (!Cools.isEmpty(steProtocol.getStatus())) {
|
vo.setStatus(steProtocol.getStatusType().desc); // 状态
|
}
|
if (!Cools.isEmpty(steProtocol.getLoad())) {
|
vo.setLoading(steProtocol.getLoad()==1?"✔":"×"); // 有物
|
}
|
if (!Cools.isEmpty(steProtocol.getWaiting())) {
|
vo.setWaiting(steProtocol.getWaiting()?"✔":"×");
|
}
|
vo.setRow(steProtocol.getRow());
|
vo.setBay(steProtocol.getBay());
|
vo.setLev(steProtocol.getLev());
|
vo.setCharge(steProtocol.getCharge() + "%");
|
if (!Cools.isEmpty(steProtocol.getLoca())) {
|
vo.setLoca(steProtocol.getLocaType().desc);
|
}
|
vo.setSpeed(steProtocol.getSpeed());
|
vo.setCloser(steProtocol.getCloser());
|
if (!Cools.isEmpty(steProtocol.getPos())) {
|
vo.setPos(steProtocol.getPos()==0?"低位":"高位");
|
}
|
if (!Cools.isEmpty(steProtocol.getTrack())) {
|
vo.setTrack(steProtocol.getTrack()==0?"✔":"×");
|
}
|
if (!Cools.isEmpty(steProtocol.getChargeStatus())) {
|
vo.setChargeStatus(steProtocol.getChargeStatus()==1?"✔":"×");
|
}
|
if (!Cools.isEmpty(steProtocol.getAlarm())) {
|
vo.setAlarm1(String.valueOf(steProtocol.getAlarm()));
|
}
|
if (!Cools.isEmpty(steProtocol.getAlarm0())) {
|
vo.setAlarm2(String.valueOf(steProtocol.getAlarm0()));
|
}
|
}
|
return R.ok().add(list);
|
}
|
|
@PostMapping("/table/ste/msg")
|
@ManagerAuth(memo = "穿梭车数据表")
|
public R steMsgTable(){
|
List<SteMsgTableVo> list = new ArrayList<>();
|
List<BasSte> stes = basSteService.selectList(new EntityWrapper<BasSte>().orderBy("ste_no"));
|
for (BasSte basSte : stes) {
|
// 表格行
|
SteMsgTableVo vo = new SteMsgTableVo();
|
vo.setSteNo(basSte.getSteNo()); // 穿梭车号
|
list.add(vo);
|
// 获取穿梭车信息
|
SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, basSte.getSteNo());
|
if (steThread == null) {
|
continue;
|
}
|
SteProtocol steProtocol = steThread.getSteProtocol();
|
if (steProtocol == null) {
|
continue;
|
}
|
|
vo.setWorkNo(steProtocol.getTaskNo().intValue()); // 任务号
|
if (steProtocol.getTaskNo() > 0) {
|
WrkMast wrkMast = wrkMastService.selectById(steProtocol.getTaskNo());
|
if (wrkMast != null) {
|
vo.setStatus(CrnStatusType.process(wrkMast.getIoType()).getDesc()); // 模式状态
|
vo.setSourceStaNo(wrkMast.getSourceStaNo$()); // 源站
|
vo.setStaNo(wrkMast.getStaNo$()); // 目标站
|
vo.setSourceLocNo(wrkMast.getSourceLocNo()); // 源库位
|
vo.setLocNo(wrkMast.getLocNo()); // 目标库位
|
}
|
} else {
|
vo.setStatus(steProtocol.mode == 1? CrnStatusType.MACHINE_AUTO.getDesc(): CrnStatusType.MACHINE_UN_AUTO.getDesc()); // 模式状态
|
}
|
vo.setSpeed(steProtocol.getSpeed()); // 速度
|
vo.setCloser(steProtocol.getCloser()); // 近点距离
|
vo.setPakMk(steProtocol.getPakMk()); // 作业标记
|
}
|
return R.ok().add(list);
|
}
|
|
@PostMapping("/output/ste")
|
@ManagerAuth
|
public R steOutput(){
|
StringBuilder str = new StringBuilder();
|
String s;
|
int i = 0;
|
while((s = OutputQueue.STE.poll()) != null && i <=10) {
|
str.append("\n").append(s);
|
i++;
|
}
|
return R.ok().add(str.toString());
|
}
|
|
@GetMapping("/detl/{steNo}")
|
public R steDetl(@PathVariable("steNo") Integer steNo){
|
SteDataVo vo = new SteDataVo();
|
for (SteSlave ste : slaveProperties.getSte()) {
|
if (steNo.equals(ste.getId())) {
|
vo.setSteNo(ste.getId());
|
BasSte basSte = basSteService.selectById(ste.getId());
|
if (!Cools.isEmpty(basSte)) {
|
vo.setRow(basSte.getRow());
|
vo.setBay(basSte.getBay());
|
vo.setLev(basSte.getLev());
|
vo.setCrnNo(basSte.getCrnNo());
|
vo.setWorkNo(basSte.getWrkNo());
|
vo.setPakMk(basSte.getPakMk());
|
}
|
break;
|
}
|
}
|
return R.ok().add(vo);
|
}
|
|
@GetMapping("/sensor/detl/{steNo}")
|
public R steSensorDetl(@PathVariable("steNo") Integer steNo){
|
SteSensorDataVo vo = new SteSensorDataVo();
|
for (SteSlave ste : slaveProperties.getSte()) {
|
if (steNo.equals(ste.getId())) {
|
vo.setSteNo(ste.getId());
|
// 获取穿梭车信息
|
SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
|
if (steThread == null) {
|
return R.error("设备不在线");
|
}
|
SteProtocol steProtocol = steThread.getSteProtocol();
|
if (steProtocol == null) {
|
return R.error("设备不在线");
|
}
|
|
// 穿梭车异常 -----------
|
vo.setLiftErr(steProtocol.isLiftErr());
|
vo.setInFetchErr(steProtocol.isInFetchErr());
|
vo.setOutFetchErr(steProtocol.isOutFetchErr());
|
vo.setAntiErr(steProtocol.isAntiErr());
|
vo.setLiftSwitchErr(steProtocol.isLiftSwitchErr());
|
vo.setTrackErr(steProtocol.isTrackErr());
|
vo.setTimeoutErr(steProtocol.isTimeoutErr());
|
vo.setConnectErr(steProtocol.isConnectErr());
|
vo.setEmergencyErr(steProtocol.isEmergencyErr());
|
vo.setTaskTypeErr(steProtocol.isTaskTypeErr());
|
vo.setTaskNoErr(steProtocol.isTaskNoErr());
|
vo.setNewTaskErr(steProtocol.isNewTaskErr());
|
vo.setErrTaskErr(steProtocol.isErrTaskErr());
|
vo.setStopErr(steProtocol.isStopErr());
|
vo.setOfflineTaskErr(steProtocol.isOfflineTaskErr());
|
vo.setStartTaskErr(steProtocol.isStartTaskErr());
|
vo.setVoltageTaskErr(steProtocol.isVoltageTaskErr());
|
vo.setDevpErr(steProtocol.isDevpErr());
|
|
// 穿梭车提示信息 ----------------------
|
vo.setOnline(steProtocol.isOnline());
|
vo.setNotOnTrack(steProtocol.isNotOnTrack());
|
vo.setLowVoltage(steProtocol.isLowVoltage());
|
vo.setElectricityLoss(steProtocol.isElectricityLoss());
|
vo.setForcedTravel(steProtocol.isForcedTravel());
|
vo.setDemoMode(steProtocol.isDemoMode());
|
vo.setBrushConnect(steProtocol.isBrushConnect());
|
vo.setTaskManualForbid(steProtocol.isTaskManualForbid());
|
vo.setOnlineManualForbid(steProtocol.isOnlineManualForbid());
|
vo.setDevpEmergency(steProtocol.isDevpEmergency());
|
vo.setTaskInterrupt(steProtocol.isTaskInterrupt());
|
vo.setTaskClear(steProtocol.isTaskClear());
|
vo.setTaskConfirmTimeout(steProtocol.isTaskConfirmTimeout());
|
vo.setTaskWithCharge(steProtocol.isTaskWithCharge());
|
|
// 任务信息 ----------------
|
vo.setPakInTask(steProtocol.isPakInTask());
|
vo.setPakOutTask(steProtocol.isPakOutTask());
|
vo.setPakMoveTask(steProtocol.isPakMoveTask());
|
vo.setGoHpTask(steProtocol.isGoHpTask());
|
vo.setGoOHpTask(steProtocol.isGoOHpTask());
|
vo.setGoHpAvoid(steProtocol.isGoHpAvoid());
|
vo.setGoOHpAvoid(steProtocol.isGoOHpAvoid());
|
vo.setPakInEmpty(steProtocol.isPakInEmpty());
|
vo.setPakInFinish(steProtocol.isPakInFinish());
|
vo.setPakOutEmpty(steProtocol.isPakOutEmpty());
|
vo.setPakOutFinish(steProtocol.isPakOutFinish());
|
vo.setGoHpAvoidFinish(steProtocol.isGoHpAvoidFinish());
|
vo.setGoOHpAvoidFinish(steProtocol.isGoOHpAvoidFinish());
|
vo.setGoHpAvoidErr(steProtocol.isGoHpAvoidErr());
|
vo.setGoOHpAvoidErr(steProtocol.isGoOHpAvoidErr());
|
|
// 状态信息 -------------
|
vo.setAutoMode(steProtocol.isAutoMode());
|
vo.setVoltageLow(steProtocol.isVoltageLow());
|
break;
|
}
|
}
|
return R.ok().add(vo);
|
}
|
|
@PostMapping("/detl/update")
|
@ManagerAuth
|
public R steUpdate(SteDataVo vo){
|
BasSte basSte = basSteService.selectById(vo.getSteNo());
|
if (basSte == null) {
|
return R.error();
|
}
|
// 获取穿梭车信息
|
SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, vo.getSteNo());
|
SteProtocol steProtocol = steThread.getSteProtocol();
|
if (steProtocol == null) {
|
throw new CoolException(vo.getSteNo() + "号穿梭车不在线，无法保存");
|
}
|
if (!Cools.isEmpty(vo.getRow(), vo.getBay(), vo.getLev())) {
|
if (!steThread.modifyPosHandle(vo.getRow(), vo.getBay(), vo.getLev())) {
|
throw new CoolException("服务器错误");
|
}
|
}
|
SteCommand steCommand = new SteCommand();
|
steCommand.setTaskNo(vo.getWorkNo());
|
if (MessageQueue.offer(SlaveType.Ste, vo.getSteNo(), new Task(2, steCommand))) {
|
} else {
|
throw new CoolException("命令下发失败");
|
}
|
basSte.setRow(vo.getRow());
|
basSte.setBay(vo.getBay());
|
basSte.setLev(vo.getLev());
|
|
basSte.setPakMk(vo.getPakMk());
|
basSte.setWrkNo(vo.getWorkNo());
|
basSte.setCrnNo(vo.getCrnNo());
|
basSte.setUpdateTime(new Date());
|
if (!basSteService.updateById(basSte)) {
|
throw new CoolException("修改失败");
|
}
|
return R.ok();
|
}
|
|
|
/****************************************************************/
|
/************************** 手动操作 ******************************/
|
/****************************************************************/
|
|
@PostMapping("/mode/switch")
|
@ManagerAuth
|
public R crnDemo(SteModeParam param) throws InterruptedException {
|
if (Cools.isEmpty(param.getSteNo())){
|
return R.error();
|
}
|
if (Cools.isEmpty(param.getPassword())){
|
return R.error("请输入口令");
|
}
|
if (!param.getPassword().equals(SystemProperties.WCS_PASSWORD)){
|
return R.error("口令错误");
|
}
|
Thread.sleep(200L);
|
for (SteSlave steSlave : slaveProperties.getSte()) {
|
if (steSlave.getId().equals(param.getSteNo())) {
|
// 获取穿梭车信息
|
SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steSlave.getId());
|
SteProtocol steProtocol = steThread.getSteProtocol();
|
if (steProtocol == null) { continue; }
|
SteCommand steCommand = new SteCommand();
|
steCommand.setSteNo(param.getSteNo()); // 穿梭车编号
|
if (steProtocol.getMode() == 0) {
|
steCommand.setControlMode((short) 1);
|
} else {
|
steCommand.setControlMode((short) 0);
|
}
|
if (MessageQueue.offer(SlaveType.Ste, param.getSteNo(), new Task(2, steCommand))) {
|
return R.ok();
|
} else {
|
throw new CoolException("命令下发失败");
|
}
|
}
|
}
|
return R.ok();
|
}
|
|
@ManagerAuth(memo = "手动操作")
|
@PostMapping("/operator/ste")
|
public R steOperator(SteOperatorParam param){
|
if (Cools.isEmpty(param.getSteNo(), param.getSteTaskMode())) {
|
return R.parse(BaseRes.PARAM);
|
}
|
|
for (SteSlave ste : slaveProperties.getSte()) {
|
// 获取堆垛机信息
|
if (param.getSteNo().equals(ste.getId())) {
|
SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
|
if (steThread == null) {
|
throw new CoolException("穿梭车不在线");
|
}
|
SteProtocol steProtocol = steThread.getSteProtocol();
|
if (steProtocol == null) {
|
throw new CoolException("穿梭车不在线");
|
}
|
SteTaskModeType steTaskModeType = SteTaskModeType.get(param.getSteTaskMode());
|
SteCommand steCommand = new SteCommand();
|
steCommand.setSteNo(ste.getId()); // 穿梭车编号
|
if (param.getSteTaskMode() == 16) {
|
steCommand.setComplete(true);
|
} else if (param.getSteTaskMode() == 99) {
|
steCommand.setControlMode((short) 1);
|
} else if (param.getSteTaskMode() == 100) {
|
steCommand.setControlMode((short) 0);
|
} else {
|
if (steTaskModeType == null) {
|
throw new CoolException("任务类型错误");
|
}
|
steCommand.setTaskNo(param.getTaskNo()); // 工作号
|
steCommand.setTaskMode(steTaskModeType);
|
}
|
if (MessageQueue.offer(SlaveType.Ste, ste.getId(), new Task(2, steCommand))) {
|
return R.ok();
|
} else {
|
throw new CoolException("命令下发失败");
|
}
|
}
|
}
|
return R.error();
|
}
|
|
}
|
