package com.zy.core.thread;
|
|
import HslCommunication.Core.Transfer.DataFormat;
|
import HslCommunication.Core.Types.OperateResult;
|
import HslCommunication.Core.Types.OperateResultExOne;
|
import HslCommunication.ModBus.ModbusTcpNet;
|
import com.alibaba.fastjson.JSON;
|
import com.core.common.DateUtils;
|
import com.core.common.RadixTools;
|
import com.core.common.SpringUtils;
|
import com.core.exception.CoolException;
|
import com.zy.asrs.entity.BasLift;
|
import com.zy.asrs.entity.BasLiftOpt;
|
import com.zy.asrs.service.BasLiftOptService;
|
import com.zy.asrs.service.BasLiftService;
|
import com.zy.common.utils.CommonUtils;
|
import com.zy.common.utils.RedisUtil;
|
import com.zy.core.DevpThread;
|
import com.zy.core.News;
|
import com.zy.core.ThreadHandler;
|
import com.zy.core.cache.MessageQueue;
|
import com.zy.core.cache.OutputQueue;
|
import com.zy.core.cache.SlaveConnection;
|
import com.zy.core.enums.*;
|
import com.zy.core.model.LiftSlave;
|
import com.zy.core.model.Task;
|
import com.zy.core.model.command.*;
|
import com.zy.core.model.protocol.LiftProtocol;
|
import com.zy.core.model.protocol.StaProtocol;
|
import lombok.Data;
|
import lombok.extern.slf4j.Slf4j;
|
|
import java.text.MessageFormat;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.List;
|
|
/**
|
* 提升机线程
|
*/
|
@Data
|
@Slf4j
|
public class LiftThread implements Runnable, ThreadHandler {
|
|
private ModbusTcpNet modbusTcpNet;
|
private LiftSlave slave;
|
private LiftProtocol liftProtocol;
|
private RedisUtil redisUtil;
|
|
public LiftThread(LiftSlave slave,RedisUtil redisUtil) {
|
this.slave = slave;
|
this.redisUtil = redisUtil;
|
}
|
|
@Override
|
public void run() {
|
this.connect();
|
while (true) {
|
try {
|
int step = 1;
|
Task task = MessageQueue.poll(SlaveType.Lift, slave.getId());
|
if (task != null) {
|
step = task.getStep();
|
}
|
switch (step) {
|
// 读数据
|
case 1:
|
readStatus();
|
break;
|
// 写入数据
|
case 2:
|
write((LiftCommand) task.getData());
|
break;
|
//分配任务
|
case 3:
|
assignWork((LiftAssignCommand) task.getData());
|
break;
|
default:
|
break;
|
}
|
Thread.sleep(500);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
|
@Override
|
public boolean connect() {
|
boolean result = false;
|
//-------------------------提升机连接方法------------------------//
|
modbusTcpNet = new ModbusTcpNet(slave.getIp(), slave.getPort(), (byte) 0x02);
|
// 当你需要指定格式的数据解析时，就需要设置下面的这个信息
|
modbusTcpNet.setDataFormat(DataFormat.ABCD);
|
OperateResult connect = modbusTcpNet.ConnectServer();
|
if(connect.IsSuccess){
|
result = true;
|
OutputQueue.CRN.offer(MessageFormat.format( "【{0}】提升机plc连接成功 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
|
log.info("提升机plc连接成功 ===>> [id:{}] [ip:{}] [port:{}] ", slave.getId(), slave.getIp(), slave.getPort());
|
} else {
|
OutputQueue.CRN.offer(MessageFormat.format("【{0}】提升机plc连接失败！！！ ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
|
log.error("提升机plc连接失败！！！ ===>> [id:{}] [ip:{}] [port:{}] ", slave.getId(), slave.getIp(), slave.getPort());
|
}
|
modbusTcpNet.ConnectClose();
|
//-------------------------提升机连接方法------------------------//
|
return result;
|
}
|
|
@Override
|
public void close() {
|
modbusTcpNet.ConnectClose();
|
}
|
|
private void readStatus() {
|
try {
|
OperateResultExOne<byte[]> result = modbusTcpNet.Read("41117", (short) 50);
|
if (result.IsSuccess) {
|
if (null == liftProtocol) {
|
liftProtocol = new LiftProtocol();
|
liftProtocol.setLiftNo(slave.getId().shortValue());
|
}
|
|
//----------读取提升机状态-----------
|
//获取数据
|
byte[] content = result.Content;
|
//提升机锁定
|
liftProtocol.setLiftLock(CommonUtils.shortToBoolean(modbusTcpNet.getByteTransform().TransInt16(content, 0)));
|
//位置到达反馈
|
liftProtocol.setPositionArrivalFeedback(modbusTcpNet.getByteTransform().TransInt16(content,2));
|
|
byte by = modbusTcpNet.getByteTransform().TransByte(content, 5);
|
int[] datas = CommonUtils.byteToBits(by);
|
//准备就绪
|
liftProtocol.setReady(CommonUtils.intToBoolean(datas[0]));
|
//运行中
|
liftProtocol.setRunning(CommonUtils.intToBoolean(datas[1]));
|
//联机/单机
|
liftProtocol.setMode(CommonUtils.intToBoolean(datas[2]));
|
//输送线前端光电有货
|
liftProtocol.setLineFrontHasStock(CommonUtils.intToBoolean(datas[3]));
|
//输送线正转反馈
|
liftProtocol.setForwardRotationFeedback(CommonUtils.intToBoolean(datas[4]));
|
//输送线反转反馈
|
liftProtocol.setReverseFeedback(CommonUtils.intToBoolean(datas[5]));
|
//输送线电机过载
|
liftProtocol.setMotorOverload(CommonUtils.intToBoolean(datas[6]));
|
//输送线末端光电有货
|
liftProtocol.setLineEndHasStock(CommonUtils.intToBoolean(datas[7]));
|
//进输送线卡托盘报警
|
liftProtocol.setInConveyLineCardTrayAlarm(CommonUtils.intToBoolean(datas[8]));
|
//出输送线卡托盘报警
|
liftProtocol.setOutConveyLineCardTrayAlarm(CommonUtils.intToBoolean(datas[9]));
|
//平台位置偏差报警
|
liftProtocol.setPlatPositionDeviationAlarm(CommonUtils.intToBoolean(datas[10]));
|
//平台扭矩偏差报警
|
liftProtocol.setPlatTorqueDeviationAlarm(CommonUtils.intToBoolean(datas[11]));
|
//平台四向车检测
|
liftProtocol.setPlatShuttleCheck(CommonUtils.intToBoolean(datas[12]));
|
|
|
//未就绪状态
|
liftProtocol.setNotReady(modbusTcpNet.getByteTransform().TransInt16(content,6));
|
//伺服1错误
|
liftProtocol.setServoError1(modbusTcpNet.getByteTransform().TransInt16(content,8));
|
//伺服2错误
|
liftProtocol.setServoError2(modbusTcpNet.getByteTransform().TransInt16(content,10));
|
//伺服3错误
|
liftProtocol.setServoError3(modbusTcpNet.getByteTransform().TransInt16(content,12));
|
//伺服4错误
|
liftProtocol.setServoError4(modbusTcpNet.getByteTransform().TransInt16(content,14));
|
//提升机实际速度反馈
|
liftProtocol.setLiftActualSpeed(modbusTcpNet.getByteTransform().TransInt16(content,16));
|
|
///读取提升机状态-end
|
|
//提升机处于运行状态，将标记置为true
|
if (liftProtocol.getRunning()) {
|
liftProtocol.setPakMk(true);
|
}
|
|
//提升机处于未运行、就绪、标记true、有任务号
|
if (!liftProtocol.getRunning()
|
&& liftProtocol.getPakMk()
|
&& liftProtocol.getTaskNo() != 0) {
|
//还有未完成的命令
|
executeWork(liftProtocol.getTaskNo());
|
}
|
|
//将提升机状态保存至数据库
|
BasLiftService liftService = SpringUtils.getBean(BasLiftService.class);
|
BasLift basLift = liftService.selectById(liftProtocol.getLiftNo());
|
if (basLift == null) {
|
basLift = new BasLift();
|
//提升机号
|
basLift.setLiftNo(slave.getId());
|
liftService.insert(basLift);
|
}
|
basLift.setStatus(liftProtocol.getProtocolStatus());
|
basLift.setWrkNo(liftProtocol.getTaskNo().intValue());
|
basLift.setUpdateTime(new Date());
|
basLift.setPakMk(liftProtocol.getPakMk());
|
basLift.setLiftLock(liftProtocol.getLiftLock());
|
basLift.setPositionArrivalFeedback(liftProtocol.getPositionArrivalFeedback().intValue());
|
basLift.setReady(liftProtocol.getReady());
|
basLift.setRunning(liftProtocol.getRunning());
|
basLift.setMode(liftProtocol.getMode());
|
basLift.setLineFrontHasStock(liftProtocol.getLineFrontHasStock());
|
basLift.setForwardRotationFeedback(liftProtocol.getForwardRotationFeedback());
|
basLift.setReverseFeedback(liftProtocol.getReverseFeedback());
|
basLift.setMotorOverload(liftProtocol.getMotorOverload());
|
basLift.setLineEndHasStock(liftProtocol.getLineEndHasStock());
|
basLift.setInConveyLineCardTrayAlarm(liftProtocol.getInConveyLineCardTrayAlarm());
|
basLift.setOutConveyLineCardTrayAlarm(liftProtocol.getOutConveyLineCardTrayAlarm());
|
basLift.setPlatPositionDeviationAlarm(liftProtocol.getPlatPositionDeviationAlarm());
|
basLift.setPlatTorqueDeviationAlarm(liftProtocol.getPlatTorqueDeviationAlarm());
|
basLift.setPlatShuttleCheck(liftProtocol.getPlatShuttleCheck());
|
basLift.setNotReady(liftProtocol.getNotReady().intValue());
|
basLift.setServoError1(liftProtocol.getServoError1().intValue());
|
basLift.setServoError2(liftProtocol.getServoError2().intValue());
|
basLift.setServoError3(liftProtocol.getServoError3().intValue());
|
basLift.setServoError4(liftProtocol.getServoError4().intValue());
|
basLift.setLiftActualSpeed(liftProtocol.getLiftActualSpeed().intValue());
|
if (liftService.updateById(basLift)) {
|
OutputQueue.LIFT.offer(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功",DateUtils.convert(new Date()), slave.getId()));
|
// log.info(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功",DateUtils.convert(new Date()), slave.getId()));
|
}
|
|
}else {
|
OutputQueue.LIFT.offer(MessageFormat.format("【{0}】{1}提升机plc状态信息失败", DateUtils.convert(new Date()), slave.getId()));
|
throw new CoolException(MessageFormat.format( "提升机plc状态信息失败 ===>> [id:{0}] [ip:{1}] [port:{2}]", slave.getId(), slave.getIp(), slave.getPort()));
|
}
|
} catch (Exception e) {
|
OutputQueue.LIFT.offer(MessageFormat.format("【{0}】提升机plc状态信息失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
|
initLift();
|
}
|
}
|
|
private boolean write(LiftCommand command){
|
if (null == command) {
|
News.error("提升机写入命令为空");
|
return false;
|
}
|
|
command.setLiftNo(slave.getId().shortValue());
|
// 开始任务
|
short[] array = new short[30];
|
//开始运行
|
array[0] = command.getRun();
|
if (command.getDistPosition() != null) {
|
//目标位置
|
array[1] = command.getDistPosition();
|
}
|
if (command.getSpeed() != null) {
|
//运行速度
|
array[2] = command.getSpeed();
|
}
|
if (command.getHeight2() != null) {
|
//二层高度设定
|
array[3] = command.getHeight2();
|
}
|
if (command.getHeight3() != null) {
|
//三层高度设定
|
array[4] = command.getHeight3();
|
}
|
if (command.getHeight4() != null) {
|
//四层高度设定
|
array[5] = command.getHeight4();
|
}
|
if (command.getHeight5() != null) {
|
//四层高度设定
|
array[6] = command.getHeight5();
|
}
|
if (command.getLiftLockShortValue() != null) {
|
//提升机锁定
|
array[29] = command.getLiftLockShortValue();
|
}
|
|
if (array[2] == 0) {
|
// 开始任务
|
short[] tmp = new short[2];
|
tmp[0] = array[0];
|
tmp[1] = array[1];
|
array = tmp;
|
}
|
|
try {
|
Thread.sleep(1000);//命令下发前休眠1s
|
} catch (InterruptedException e) {
|
throw new RuntimeException(e);
|
}
|
|
OperateResult result = modbusTcpNet.Write("41088", array);;
|
if (result != null && result.IsSuccess) {
|
News.info("提升机命令下发[id:{}] >>>>> {}", slave.getId(), JSON.toJSON(command));
|
OutputQueue.LIFT.offer(MessageFormat.format("【{0}】[id:{1}] >>>>> 命令下发： {2}", DateUtils.convert(new Date()), slave.getId(), JSON.toJSON(command)));
|
return true;
|
} else {
|
OutputQueue.LIFT.offer(MessageFormat.format("【{0}】写入提升机plc数据失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
|
News.error("写入提升机plc数据失败 ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
|
return false;
|
}
|
}
|
|
//分配任务
|
private void assignWork(LiftAssignCommand assignCommand) {
|
//手动模式指令
|
if (!assignCommand.getAuto()) {
|
LiftCommand command = new LiftCommand();
|
//提升机当前楼层
|
Short lev = liftProtocol.getLev();
|
List<LiftCommand> commands = assignCommand.getCommands();
|
if (commands == null) {
|
commands = new ArrayList<LiftCommand>();
|
}
|
liftProtocol.setTaskNo(assignCommand.getTaskNo());
|
switch (assignCommand.getTaskMode()) {
|
case 1://移动提升机
|
command = getLiftUpDownCommand(assignCommand.getLev());//获取提升机上升下降命令
|
break;
|
case 3://无货正转
|
command = getLiftTurnCommand(3);//获取提升机转动命令
|
break;
|
case 4://无货反转
|
command = getLiftTurnCommand(4);//获取提升机转动命令
|
break;
|
case 5://有货正转
|
command = getLiftTurnCommand(1);//获取提升机转动命令
|
break;
|
case 6://有货反转
|
command = getLiftTurnCommand(2);//获取提升机转动命令
|
break;
|
case 7://链条停止
|
command = getLiftTurnCommand(5);//获取提升机转动命令
|
break;
|
case 0://复位
|
command = getResetCommand();//获取复位命令
|
break;
|
default:
|
}
|
commands.add(command);
|
assignCommand.setCommands(commands);
|
}
|
|
LiftRedisCommand redisCommand = new LiftRedisCommand();
|
redisCommand.setLiftNo(assignCommand.getLiftNo());//提升机号
|
redisCommand.setWrkNo(assignCommand.getTaskNo());//工作号
|
redisCommand.setCommandStep(0);//命令执行步序
|
redisCommand.setAssignCommand(assignCommand);//命令
|
//任务数据保存到redis
|
redisUtil.set("lift_wrk_no_" + assignCommand.getTaskNo(), JSON.toJSONString(redisCommand));
|
liftProtocol.setAssignCommand(assignCommand);
|
liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);
|
//执行下发任务
|
executeWork(assignCommand.getTaskNo());
|
}
|
|
//执行任务
|
private boolean executeWork(Short wrkNo) {
|
//读取redis数据
|
if (wrkNo == null) {
|
return false;
|
}
|
|
//将标记置为false(防止重发)
|
liftProtocol.setPakMk(false);
|
|
Object o = redisUtil.get("lift_wrk_no_" + wrkNo);
|
if (o == null) {
|
return false;
|
}
|
LiftRedisCommand redisCommand = JSON.parseObject(o.toString(), LiftRedisCommand.class);
|
List<LiftCommand> commands = redisCommand.getAssignCommand().getCommands();
|
//当前步序
|
int commandStep = redisCommand.getCommandStep();
|
//总步序
|
int size = commands.size();
|
LiftAssignCommand assignCommand = redisCommand.getAssignCommand();
|
|
//取出命令
|
LiftCommand command = commands.get(commandStep);
|
if (command.getOperaStaNo() != null && command.getDevpId() != null) {
|
//站点和输送线ID不为null，需要下发站点指令调度指定站点进行链条转动
|
DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, command.getDevpId());
|
StaProtocol staProtocol = devpThread.getStation().get(command.getOperaStaNo().intValue());
|
if (!staProtocol.isLiftArrival()) {//链条转动条件，需要有提升机到位信号
|
liftProtocol.setPakMk(true);
|
return false;
|
}
|
staProtocol.setWorkNo(wrkNo);//设置任务号
|
if (command.getStaNo() != null) {
|
staProtocol.setStaNo(command.getStaNo());//设置目标站
|
}
|
|
if (command.getRotationDire() != null) {
|
staProtocol.setRotationDire(command.getRotationDire());//站点链条转动信号
|
}
|
Integer devpId = command.getDevpId();
|
boolean result1 = MessageQueue.offer(SlaveType.Devp, devpId, new Task(3, staProtocol));//下发命令使输送线链条运转
|
}
|
|
//下发命令
|
if (!write(command)) {
|
News.error("提升机命令下发失败，提升机号={}，任务数据={}", command.getLiftNo(), JSON.toJSON(command));
|
return false;
|
}else {
|
News.info("提升机命令下发成功，提升机号={}，任务数据={}", command.getLiftNo(), JSON.toJSON(command));
|
liftProtocol.setWrkTime(new Date());//更新工作时间
|
|
//保存数据到数据库做流水
|
BasLiftOptService liftOptService = SpringUtils.getBean(BasLiftOptService.class);
|
if (liftOptService != null) {
|
BasLiftOpt opt = new BasLiftOpt(
|
redisCommand.getWrkNo().intValue(),
|
redisCommand.getLiftNo().intValue(),
|
new Date(),
|
null,
|
null,
|
null,
|
JSON.toJSONString(command)
|
);
|
liftOptService.insert(opt);
|
}
|
|
try {
|
Thread.sleep(1000);//命令下发完成后休眠1s
|
} catch (InterruptedException e) {
|
throw new RuntimeException(e);
|
}
|
|
//判断数据是否执行完成
|
if (commandStep < size - 1) {
|
//更新redis数据
|
//步序增加
|
commandStep++;
|
redisCommand.setCommandStep(commandStep);
|
//任务数据保存到redis
|
redisUtil.set("lift_wrk_no_" + redisCommand.getWrkNo(), JSON.toJSONString(redisCommand));
|
}else {
|
//已执行完成
|
//删除redis
|
redisUtil.del("lift_wrk_no_" + redisCommand.getWrkNo());
|
|
//对主线程抛出等待确认状态waiting
|
liftProtocol.setProtocolStatus(LiftProtocolStatusType.WAITING);
|
News.info("提升机任务执行完成等待确认中，提升机号={}，任务数据={}", command.getLiftNo(), JSON.toJSON(command));
|
|
}
|
}
|
|
return true;
|
}
|
|
/**
|
* 获取提升机解锁命令
|
*/
|
public LiftCommand getUnlockCommand(Short liftNo) {
|
LiftCommand command = new LiftCommand();
|
command.setRun((short) 0);
|
command.setLiftNo(liftNo);
|
command.setLiftLock(false);
|
return command;
|
}
|
|
/**
|
* 获取复位命令
|
*/
|
public LiftCommand getResetCommand() {
|
LiftCommand command = new LiftCommand();
|
command.setRun((short) 5);
|
command.setLiftLock(false);
|
return command;
|
}
|
|
/**
|
* 获取提升机上升下降命令
|
*/
|
public LiftCommand getLiftUpDownCommand(Integer lev) {
|
LiftCommand command = new LiftCommand();
|
command.setRun((short) 1);//升降
|
Short position = LiftLevType.getRealLev(lev);//获取提升机实际楼层数值
|
command.setDistPosition(position);
|
// command.setSpeed((short) 200);
|
// command.setHeight2((short) 180);
|
// command.setHeight3((short) 1645);
|
// command.setHeight4((short) (2 * 1645));
|
// command.setHeight5((short) (3 * 1645));
|
return command;
|
}
|
|
/**
|
* 获取提升机上升下降命令
|
*/
|
public LiftCommand getLiftUpDownCommand(Short liftNo, Short taskNo, Integer lev) {
|
LiftCommand command = new LiftCommand();
|
Short position = LiftLevType.getRealLev(lev);//获取提升机实际楼层数值
|
command.setRun((short) 1);//升降
|
command.setLiftNo(liftNo);//提升机号
|
command.setTaskNo(taskNo);//任务号
|
command.setDistPosition(position);//目标楼层
|
// command.setSpeed((short) 200);
|
// command.setHeight2((short) 180);
|
// command.setHeight3((short) 1645);
|
// command.setHeight4((short) 3290);
|
// command.setHeight5((short) 4945);
|
return command;
|
}
|
|
/**
|
* 获取提升机转动命令，direction：1=》有货正转，2=》有货反转，3=>无货正转，4=>无货反转
|
*/
|
public LiftCommand getLiftTurnCommand(Integer direction) {
|
LiftCommand command = new LiftCommand();
|
Short run = 0;
|
switch (direction) {
|
case 1:
|
run = 6;//有货正转
|
break;
|
case 2:
|
run = 3;//有货反转
|
break;
|
case 3:
|
run = 2;//无货正转
|
break;
|
case 4:
|
run = 7;//无货反转
|
break;
|
case 5:
|
run = 4;//链条停止
|
}
|
command.setRun(run);
|
return command;
|
}
|
|
/**
|
* 获取提升机转动命令，direction：1=》有货正转，2=》有货反转
|
*/
|
public LiftCommand getLiftTurnCommand(Short liftNo, Short taskNo, Integer direction) {
|
LiftCommand command = new LiftCommand();
|
Short run = 0;
|
switch (direction) {
|
case 1:
|
run = 6;//有货正转
|
break;
|
case 2:
|
run = 3;//有货反转
|
break;
|
case 3:
|
run = 2;//无货正转
|
break;
|
case 4:
|
run = 7;//无货反转
|
break;
|
case 5:
|
run = 4;//链条停止
|
}
|
command.setRun(run);
|
command.setLiftNo(liftNo);//提升机号
|
command.setTaskNo(taskNo);//任务号
|
return command;
|
}
|
|
/**
|
* 初始化提升机
|
*/
|
private void initLift() {
|
if (null == liftProtocol) {
|
liftProtocol = new LiftProtocol();
|
}
|
}
|
|
/******************************************************************************************/
|
/**************************************** 测试专用 *****************************************/
|
/*****************************************************************************************/
|
public static void main(String[] args) throws InterruptedException {
|
LiftSlave slave = new LiftSlave();
|
slave.setId(1);
|
slave.setIp("192.168.4.24");
|
slave.setPort(502);
|
// LiftThread thread = new LiftThread(slave,);
|
// thread.connect();
|
// thread.readStatus();
|
//
|
// LiftCommand command = new LiftCommand();
|
// command.setRun((short) 1);
|
// command.setDistPosition((short) 12);
|
// command.setSpeed((short) 300);
|
// command.setHeight2((short) 100);
|
// command.setHeight3((short) 200);
|
// command.setHeight4((short) 303);
|
// command.setLiftLock(true);
|
// thread.write(command);
|
|
}
|
|
}
|
