From 9f2ce9aff3d12d9519e244464ef3355f56cf4452 Mon Sep 17 00:00:00 2001 From: zhaohe Date: Tue, 15 Oct 2024 20:18:04 +0800 Subject: [PATCH] update --- app.db | Bin 225280 -> 225280 bytes src/main/java/a8k/constant/MiniServoConstant.java | 49 ++ .../devicedriver/basectrl/MiniServoControler.java | 39 +- .../basectrl/TubeTransportControler.java | 5 +- .../TubeFeedingModulePosCalibration.java | 4 +- .../calibration/TubePreProcesPosCalibration.java | 197 ++++-- .../commonctrl/HardwareCommonCtrl.java | 754 ++++++++++----------- .../devicedriver/ctrl/DeviceInitCtrlService.java | 10 +- .../devicedriver/ctrl/TubePreProcesControler.java | 352 +++++----- .../devicedriver/pos/TubeFeedingModulePosMgr.java | 13 +- .../app/devicedriver/pos/TubePreProcesPosMgr.java | 143 +--- .../service/db/LowerDeviceParameterDBService.java | 1 + 12 files changed, 824 insertions(+), 743 deletions(-) create mode 100644 src/main/java/a8k/constant/MiniServoConstant.java diff --git a/app.db b/app.db index ced499845393ec5238c33509e95c7653b9d494af..6110e76508757b39922211c66a7e9bd920322edb 100644 GIT binary patch delta 242 zcmZp8z}xVEcY>6V#!dzX26G@b17dat2DYOUb&Qxab~YxoCNOSIU}6nqYOCL#9>^5S z$kbN1{a6swI%cM}+UaFsOb3|SYNme(Woq8OI~*)syKjT^HLJ? zk}HD?5|cCY(%tflLQ0cTof8W@^GZ_FQ;UoY%r$|UjHN}VA6&vD4ARCk{oEoZer7WR mgY6F%G1;;(8cdg4&Q!o`YG^ur;&LVnCNqQWr delta 186 zcmZp8z}xVEcY>6VN(lo4gEFf)b>NhJ2C^B)FYqBvI8%v8$Ke&WRczVHdCZ6f%7BTTNo0=PM kf3S$jmW9z`y4-T60%l_ii|G@WGg&Yh8*e|ooXPYA0Fd!DAOHXW diff --git a/src/main/java/a8k/constant/MiniServoConstant.java b/src/main/java/a8k/constant/MiniServoConstant.java new file mode 100644 index 0000000..7b0ff01 --- /dev/null +++ b/src/main/java/a8k/constant/MiniServoConstant.java @@ -0,0 +1,49 @@ +package a8k.constant; + +import a8k.service.app.devicedriver.basectrl.type.MiniServoMId; + +public class MiniServoConstant { + static public final Integer actionOvertime = 5000; + + //摇匀模组Y轴 + static public final Integer ShakeModGripperYSV_zeroPos = 110; + static public final Integer ShakeModGripperYSV_refPos = 100;//Y轴最外侧的位置 + + //摇匀模组夹爪 + static public final Integer ShakeModGripperSV_zeroPos = 1600; + static public final Integer ShakeModGripperSV_refPos = 1800;//完全张开的位置 + + //试管架夹紧 + static public final Integer ShakeModTubeScanerClampingSV_zeroPos = 1800; + static public final Integer ShakeModTubeScanerClampingSV_refPos = 1800;//水平位置 + + + static public Integer getZeroPos(MiniServoMId mid) { + return getInteger(mid, + ShakeModGripperYSV_zeroPos, + ShakeModGripperSV_zeroPos, + ShakeModTubeScanerClampingSV_zeroPos); + + } + + static public Integer getRefPos(MiniServoMId mid) { + return getInteger(mid, + ShakeModGripperYSV_refPos, + ShakeModGripperSV_refPos, + ShakeModTubeScanerClampingSV_refPos); + } + + private static Integer getInteger(MiniServoMId mid, Integer ShakeModGripperYSVPos, Integer ShakeModGripperSVPos, Integer ShakeModTubeScanerClampingSVPos) { + switch (mid) { + case ShakeModGripperYSV: + return ShakeModGripperYSVPos; + case ShakeModGripperSV: + return ShakeModGripperSVPos; + case ShakeModTubeScanerClampingSV: + return ShakeModTubeScanerClampingSVPos; + case ShakeModTubeScanerRotateSV: + assert false; + } + return 0; + } +} diff --git a/src/main/java/a8k/service/app/devicedriver/basectrl/MiniServoControler.java b/src/main/java/a8k/service/app/devicedriver/basectrl/MiniServoControler.java index ebece85..2363192 100644 --- a/src/main/java/a8k/service/app/devicedriver/basectrl/MiniServoControler.java +++ b/src/main/java/a8k/service/app/devicedriver/basectrl/MiniServoControler.java @@ -1,5 +1,6 @@ package a8k.service.app.devicedriver.basectrl; +import a8k.constant.MiniServoConstant; import a8k.hardware.A8kCanBusService; import a8k.hardware.type.a8kcanprotocol.A8kEcode; import a8k.hardware.type.a8kcanprotocol.CmdId; @@ -8,15 +9,20 @@ import a8k.service.app.devicedriver.basectrl.type.MiniServoMId; import a8k.type.ecode.HardwareError; import a8k.type.exception.AppException; import jakarta.annotation.Resource; +import org.slf4j.Logger; import org.springframework.stereotype.Component; + @Component public class MiniServoControler { + Logger logger = org.slf4j.LoggerFactory.getLogger(MiniServoControler.class); + @Resource A8kCanBusService canBus; public void miniServoEnable(MiniServoMId id, int enable) throws AppException { + logger.info("{} miniServoEnable {}", id.mid, enable); canBus.callcmd(id.mid, CmdId.mini_servo_enable, enable); } @@ -25,6 +31,11 @@ public class MiniServoControler { return packet.getContentI32(0); } + public void miniServoMoveToZeroBlock(MiniServoMId id) throws AppException { + logger.info("{} miniServoMoveToZero", id.mid); + miniServoMoveToBlock(id, MiniServoConstant.getZeroPos(id)); + } + public void miniServoActiveCfg(MiniServoMId id) throws AppException { canBus.callcmd(id.mid, CmdId.mini_servo_active_cfg); } @@ -46,34 +57,44 @@ public class MiniServoControler { canBus.callcmd(id.mid, CmdId.mini_servo_move_to, pos); } - public void miniServoMoveToBlock(MiniServoMId id, int pos, Integer actionOvertime) throws AppException { + public void miniServoMoveToBlock(MiniServoMId id, int pos) throws AppException { + logger.info("{} miniServoMoveTo {}", id.mid, pos); miniServoMoveTo(id, pos); - canBus.waitForMod(id.mid, actionOvertime); + canBus.waitForMod(id.mid, MiniServoConstant.actionOvertime); } public void miniServoRotate(MiniServoMId id, int direction) throws AppException { + logger.info("{} miniServoRotate {}", id.mid, direction); canBus.callcmd(id.mid, CmdId.mini_servo_rotate, direction); } - public void miniServoRotateBlock(MiniServoMId id, int direction, Integer actionOvertime) throws AppException { + public void miniServoRotateBlock(MiniServoMId id, int direction) throws AppException { miniServoRotate(id, direction); - canBus.waitForMod(id.mid, actionOvertime); + canBus.waitForMod(id.mid, MiniServoConstant.actionOvertime); } public void miniServoRotateWithTorque(MiniServoMId id, int torque) throws AppException { + logger.info("{} miniServoRotateWithTorque {}", id.mid, torque); canBus.callcmd(id.mid, CmdId.mini_servo_rotate_with_torque, torque); } - public void miniServoRotateWithTorqueBlock(MiniServoMId id, int torque, Integer actionOvertime) throws AppException { - miniServoRotateWithTorque(id, torque); - miniServoWaitIsNotMove(id, actionOvertime); - } + // public void miniServoRotateWithTorqueBlock(MiniServoMId id, int torque) throws AppException { + // miniServoRotateWithTorque(id, torque); + // miniServoWaitIsNotMove(id, actionOvertime); + // } // kmini_servo_set_cur_pos - public void miniServoSetCurPos(MiniServoMId id, Integer pos) throws AppException { + private void miniServoSetCurPos(MiniServoMId id, Integer pos) throws AppException { + logger.info("{} miniServoSetCurPos {}", id.mid, pos); canBus.callcmdOvertime(id.mid, CmdId.mini_servo_set_cur_pos, 5000, pos); } + public Integer miniServoSetRefPos(MiniServoMId id) throws AppException { + miniServoSetCurPos(id, MiniServoConstant.getRefPos(id)); + return MiniServoConstant.getRefPos(id); + } + + public void miniServoWaitIsNotMove(MiniServoMId id, int acitionOvertime) throws AppException { long startedAt = System.currentTimeMillis(); do { diff --git a/src/main/java/a8k/service/app/devicedriver/basectrl/TubeTransportControler.java b/src/main/java/a8k/service/app/devicedriver/basectrl/TubeTransportControler.java index 63e62ce..993d915 100644 --- a/src/main/java/a8k/service/app/devicedriver/basectrl/TubeTransportControler.java +++ b/src/main/java/a8k/service/app/devicedriver/basectrl/TubeTransportControler.java @@ -1,5 +1,6 @@ package a8k.service.app.devicedriver.basectrl; +import a8k.constant.MiniServoConstant; import a8k.extapi_controler.utils.ExtApiFn; import a8k.hardware.A8kCanBusService; import a8k.hardware.type.a8kcanprotocol.A8kEcode; @@ -72,7 +73,7 @@ public class TubeTransportControler { public void scanClampModClamp() throws AppException { logger.info("扫描夹紧机构夹紧"); miniServoControler.miniServoEnable(MiniServoMId.ShakeModTubeScanerClampingSV, 1); - miniServoControler.miniServoMoveTo(MiniServoMId.ShakeModTubeScanerClampingSV, tubeScanPosMgr.ScanerClampingSVClampingPos); + miniServoControler.miniServoMoveTo(MiniServoMId.ShakeModTubeScanerClampingSV, MiniServoConstant.getZeroPos(MiniServoMId.ShakeModTubeScanerClampingSV) + 900); canBus.waitForMod(MId.ShakeModTubeScanerClampingSV, overtime); } @@ -80,7 +81,7 @@ public class TubeTransportControler { public void scanClampModRelease() throws AppException { logger.info("扫描夹紧机构复位"); miniServoControler.miniServoEnable(MiniServoMId.ShakeModTubeScanerClampingSV, 1); - miniServoControler.miniServoMoveTo(MiniServoMId.ShakeModTubeScanerClampingSV, tubeScanPosMgr.ScanerClampingSVReleasePos); + miniServoControler.miniServoMoveTo(MiniServoMId.ShakeModTubeScanerClampingSV, MiniServoConstant.getZeroPos(MiniServoMId.ShakeModTubeScanerClampingSV)); canBus.waitForMod(MId.ShakeModTubeScanerClampingSV, overtime); } diff --git a/src/main/java/a8k/service/app/devicedriver/calibration/TubeFeedingModulePosCalibration.java b/src/main/java/a8k/service/app/devicedriver/calibration/TubeFeedingModulePosCalibration.java index 273cae5..95afef0 100644 --- a/src/main/java/a8k/service/app/devicedriver/calibration/TubeFeedingModulePosCalibration.java +++ b/src/main/java/a8k/service/app/devicedriver/calibration/TubeFeedingModulePosCalibration.java @@ -101,9 +101,9 @@ public class TubeFeedingModulePosCalibration { tubeScanPosMgr.setTube0ExistJudgXPos(readFeedingModXMPos()); } - @ExtApiFn(name = "<夹紧舵机>设置当前位置为夹紧位置", group = "标定", order = 26) + @ExtApiFn(name = "<夹紧舵机>设置当前位置参考点(水平位置)", group = "设定", order = 26) public void setTubeScanClampPos() throws AppException { - miniServoControler.miniServoSetCurPos(MiniServoMId.ShakeModTubeScanerClampingSV, tubeScanPosMgr.ScanerClampingSVClampingPos); + miniServoControler.miniServoSetRefPos(MiniServoMId.ShakeModTubeScanerClampingSV); } diff --git a/src/main/java/a8k/service/app/devicedriver/calibration/TubePreProcesPosCalibration.java b/src/main/java/a8k/service/app/devicedriver/calibration/TubePreProcesPosCalibration.java index 2e73805..803c027 100644 --- a/src/main/java/a8k/service/app/devicedriver/calibration/TubePreProcesPosCalibration.java +++ b/src/main/java/a8k/service/app/devicedriver/calibration/TubePreProcesPosCalibration.java @@ -3,8 +3,6 @@ package a8k.service.app.devicedriver.calibration; import a8k.extapi_controler.pagecontrol.ExtApiTabConfig; import a8k.extapi_controler.utils.ExtApiFn; import a8k.extapi_controler.utils.ExtApiTab; -import a8k.hardware.A8kCanBusService; -import a8k.hardware.type.a8kcanprotocol.MId; import a8k.service.app.devicedriver.basectrl.MiniServoControler; import a8k.service.app.devicedriver.basectrl.StepMotorControler; import a8k.service.app.devicedriver.basectrl.type.MiniServoMId; @@ -22,42 +20,39 @@ public class TubePreProcesPosCalibration { final static Integer overtime = 6000; @Resource - TubePreProcesPosMgr tubePreProcesPosMgr; + TubePreProcesPosMgr posMgr; @Resource - A8kCanBusService canBus; - @Resource MiniServoControler miniServoControler; @Resource StepMotorControler stepMotorControler; @Resource - TubePreProcesControler tubePreProcesControler; + TubePreProcesControler controler; //基础工具 - @ExtApiFn(name = "归零", group = "测试工具", order = 11) + @ExtApiFn(name = "归零", group = "测试工具", order = 1) public void deviceReset() throws AppException { enableModule(); - stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.FeedingModXM, 15000); - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModTubeScanerClampingSV, 20, overtime); - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, 300, overtime); - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperYSV, 300, overtime); - stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModClampingM, overtime); + miniServoControler.miniServoMoveToZeroBlock(MiniServoMId.ShakeModGripperSV); stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModGripperZM, overtime); + miniServoControler.miniServoMoveToZeroBlock(MiniServoMId.ShakeModGripperYSV); + + stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModClampingM, overtime); stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModShakeM, overtime); stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModShakeM, 90, overtime); + stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModClampingM, posMgr.getShakeClampMotorReleasePos(), overtime); } - @ExtApiFn(name = "使能相关模块", group = "测试工具", order = 12) + @ExtApiFn(name = "使能相关模块", group = "测试工具", order = 2) public void enableModule() throws AppException { miniServoControler.miniServoEnable(MiniServoMId.ShakeModGripperSV, 1); miniServoControler.miniServoEnable(MiniServoMId.ShakeModGripperYSV, 1); stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModClampingM, 1); stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModGripperZM, 1); stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModShakeM, 1); - stepMotorControler.stepMotorEnable(StepMotorMId.FeedingModXM, 1); } - @ExtApiFn(name = "失能相关模块", group = "测试工具", order = 13) + @ExtApiFn(name = "失能相关模块", group = "测试工具", order = 3) public void disableModule() throws AppException { miniServoControler.miniServoEnable(MiniServoMId.ShakeModGripperSV, 0); miniServoControler.miniServoEnable(MiniServoMId.ShakeModGripperYSV, 0); @@ -66,62 +61,186 @@ public class TubePreProcesPosCalibration { stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModShakeM, 0); stepMotorControler.stepMotorEnable(StepMotorMId.FeedingModXM, 0); } - @ExtApiFn(name = "读取夹爪当前位置", group = "测试工具", order = 13) - public Integer readGripperPos() throws AppException { - return miniServoControler.miniServoReadPos(MiniServoMId.ShakeModGripperSV); + + // @ExtApiFn(name = "读取夹爪当前位置", group = "测试工具", order = 4) + // public Integer readGripperPos() throws AppException { + // return miniServoControler.miniServoReadPos(MiniServoMId.ShakeModGripperSV); + // } + + @ExtApiFn(name = "读取所有设定值", group = "测试工具", order = 5) + public TubePreProcesPosMgr getPoss() { + return posMgr; + } + + // @ExtApiFn() + // GripperRedundancySpacingForTubeCap + + @ExtApiFn(name = "设置夹爪试管盖冗余间距", group = "其他设置", order = 6) + public void setGripperRedundancySpacingForTubeCap(Integer value) { + posMgr.setGripperRedundancySpacingForTubeCap(value); } - //标定和校准 - //夹爪 : 设置参考点,标定,验证 - //YSV : 设置参考点,标定,验证 - //ZM : 标定,验证 - //XProcessPos: 标定,验证 - //ShakeClamp : 标定,校验 // // 夹爪标定,校准,校验 // - @ExtApiFn(name = "设置当前位置为<参考点>", group = "夹爪", order = 21) + @ExtApiFn(name = "设置当前位置为<参考点>(完全张开的位置)", group = "标定.夹爪", order = 21, newline = true) public Integer gripperSVSetCurrentPosAsRef() throws AppException { - miniServoControler.miniServoSetCurPos(MiniServoMId.ShakeModGripperSV, 1800); + miniServoControler.miniServoSetRefPos(MiniServoMId.ShakeModGripperSV); return 1800; } - @ExtApiFn(name = "<标定>当前点为<抓手张开位置>", group = "夹爪", order = 22) + @ExtApiFn(name = "<标定>当前点为<抓手张开位置>", group = "标定.夹爪", order = 22) public Integer gripperSVSetCurrentPosAsOpenPos() throws AppException { Integer pos = miniServoControler.miniServoReadPos(MiniServoMId.ShakeModGripperSV); - tubePreProcesPosMgr.setGripperServoOpenPos(pos); + posMgr.setGripperServoOpenPos(pos); return pos; } - @ExtApiFn(name = "<标定>当前点为<抓手闭合位置>", group = "夹爪", order = 23) + @ExtApiFn(name = "<标定>当前点为<抓手闭合位置>", group = "标定.夹爪", order = 23) public Integer gripperSVSetCurrentPosAsClosePos() throws AppException { - Integer pos = miniServoControler.miniServoReadPos(MiniServoMId.ShakeModGripperSV); - tubePreProcesPosMgr.setGripperServoClosePos(pos); + int pos = miniServoControler.miniServoReadPos(MiniServoMId.ShakeModGripperSV); + posMgr.setGripperServoClosePos(pos + 2); return pos; } - @ExtApiFn(name = "<标定>当前点为<抓手取试管位置>", group = "夹爪", order = 24) + @ExtApiFn(name = "<标定>当前点为<抓手取试管位置>", group = "标定.夹爪", order = 24) public Integer gripperSVSetCurrentPosAsTakeCapPos() throws AppException { Integer pos = miniServoControler.miniServoReadPos(MiniServoMId.ShakeModGripperSV); - tubePreProcesPosMgr.setGripperServoTakeCapPos(pos); + posMgr.setGripperServoTakeCapPos(pos - 5); return pos; } - @ExtApiFn(name = "<校验>张开", group = "夹爪", order = 26) + @ExtApiFn(name = "<校验>张开", group = "校验.夹爪", order = 26) public void gripperSVOpen() throws AppException { - tubePreProcesControler.gripperSVOpen(); + miniServoControler.miniServoEnable(MiniServoMId.ShakeModGripperSV, 1); + controler.gripperSVOpen(); } - @ExtApiFn(name = "<校验>夹紧", group = "夹爪", order = 25) + @ExtApiFn(name = "<校验>夹紧", group = "校验.夹爪", order = 25) public void gripperSVCClose() throws AppException { - tubePreProcesControler.gripperSVCClose(); + miniServoControler.miniServoEnable(MiniServoMId.ShakeModGripperSV, 1); + controler.gripperSVCClose(); } - @ExtApiFn(name = "<校验>夹住试管", group = "夹爪", order = 25) + @ExtApiFn(name = "<校验>夹住试管", group = "校验.夹爪", order = 25) public void gripperSVClampTube() throws AppException { - tubePreProcesControler.gripperSVClampTube(); + miniServoControler.miniServoEnable(MiniServoMId.ShakeModGripperSV, 1); + controler.gripperSVClampTube(); + } + + // + //YSV : 设置参考点,标定,验证 + // + + @ExtApiFn(name = "设置当前位置为<参考点>(Y轴最外侧的位置)", group = "标定.YSV", order = 31, newline = true) + public Integer YAxixServoSetCurrentPosAsRef() throws AppException { + return miniServoControler.miniServoSetRefPos(MiniServoMId.ShakeModGripperYSV); + } + + @ExtApiFn(name = "<标定>当前点为<取试管位置>", group = "标定.YSV", order = 32) + public Integer YAxixServoSetCurrentPosAsTakeTubePos() throws AppException { + Integer pos = miniServoControler.miniServoReadPos(MiniServoMId.ShakeModGripperYSV); + posMgr.setYServoTakeTubePos(pos); + return pos; + } + + @ExtApiFn(name = "<标定>当前点为<摇晃位置>", group = "标定.YSV", order = 33) + public Integer YAxixServoSetCurrentPosAsShakePos() throws AppException { + Integer pos = miniServoControler.miniServoReadPos(MiniServoMId.ShakeModGripperYSV); + posMgr.setYServoShakePos(pos); + return pos; + } + + @ExtApiFn(name = "<校验>移动到摇匀位", group = "校验.YSV", order = 35) + public void YAxixServoShake() throws AppException { + miniServoControler.miniServoEnable(MiniServoMId.ShakeModGripperYSV, 1); + controler.YSVMoveToShakePos(); + } + + @ExtApiFn(name = "<校验>移动到取试管位", group = "校验.YSV", order = 36) + public void YAxixServoTakeTube() throws AppException { + miniServoControler.miniServoEnable(MiniServoMId.ShakeModGripperYSV, 1); + controler.YSVMoveToTakeTubePos(); } + @ExtApiFn(name = "<校验>移动到待机位", group = "校验.YSV", order = 37) + public void YAxixServoMoveToStandyPos(Integer pos) throws AppException { + miniServoControler.miniServoEnable(MiniServoMId.ShakeModGripperYSV, 1); + controler.YSVMoveToStandyPos(); + } + + // + //ZM : 标定,验证 + // + + @ExtApiFn(name = "<标定>设置当前点为取高试管的位置", group = "标定.ZM", order = 41, newline = true) + public Integer ZMotorSetTakeHTubePos() throws AppException { + Integer pos = stepMotorControler.stepMotorReadPosByMoveToZeroBlock(StepMotorMId.ShakeModGripperZM, 10000); + posMgr.setZMotorTakeHTubePos(pos); + return pos; + } + + // @ExtApiFn(name = "<标定>设置当前点为取短试管的位置", group = "标定.ZM", order = 42) + // public Integer ZMotorSetTakeSTubePos() throws AppException { + // Integer pos = stepMotorControler.stepMotorReadPosByMoveToZeroBlock(StepMotorMId.ShakeModGripperZM, 10000); + // tubePreProcesPosMgr.setZMotorTakeSTubePos(pos); + // return pos; + // } + + @ExtApiFn(name = "<标定>设置当前点为摇匀位置", group = "标定.ZM", order = 43) + public Integer ZMotorSetShakeTubePos() throws AppException { + Integer pos = stepMotorControler.stepMotorReadPosByMoveToZeroBlock(StepMotorMId.ShakeModGripperZM, 10000); + posMgr.setZMotorShakeTubePos(pos); + return pos; + } + + @ExtApiFn(name = "<校验>取试管", group = "校验.ZM", order = 45) + public void takeTube() throws AppException { + enableModule(); + controler.takeTubeFromTubeholder(); + } + + @ExtApiFn(name = "<校验>放试管", group = "校验.ZM", order = 46) + public void putTube() throws AppException { + enableModule(); + controler.putTubeToTubeholder(); + } + + + //ShakeClamp : 标定,校验 + @ExtApiFn(name = "<标定>设置当前点为<夹紧位置>", group = "标定.夹紧", order = 51, newline = true) + public void ShakeModClampingSetShakeClampMotorClampPos() throws AppException { + enableModule(); + Integer value = stepMotorControler.stepMotorReadPosByMoveToZeroBlock(StepMotorMId.ShakeModClampingM, 10000); + posMgr.setShakeClampMotorClampPos(value - 2); + } + + @ExtApiFn(name = "<标定>设置当前点为<释放位置>", group = "标定.夹紧", order = 52) + public void ShakeModClampingSetShakeClampMotorReleasePos() throws AppException { + enableModule(); + Integer value = stepMotorControler.stepMotorReadPosByMoveToZeroBlock(StepMotorMId.ShakeModClampingM, 10000); + posMgr.setShakeClampMotorReleasePos(value); + } + + @ExtApiFn(name = "<校验>夹紧", group = "校验.夹紧", order = 53) + public void clampTube() throws AppException { + controler.clampingMclampTube(); + } + + @ExtApiFn(name = "<校验>释放", group = "校验.夹紧", order = 54) + public void unclampTube() throws AppException { + controler.clampingMReleaseTube(); + } + + @ExtApiFn(name = "<校验>全部流程", group = "校验.全部", order = 60) + public void testAll() throws AppException { + controler.takeTubeFromTubeholderToShakePos(); + controler.shakeTube(45, 5); + controler.takeTubeCap(); + controler.putbakTubeCapAndPutbakTubeToTubeHolder(); + } } + + diff --git a/src/main/java/a8k/service/app/devicedriver/commonctrl/HardwareCommonCtrl.java b/src/main/java/a8k/service/app/devicedriver/commonctrl/HardwareCommonCtrl.java index b0cfb55..ac569f5 100644 --- a/src/main/java/a8k/service/app/devicedriver/commonctrl/HardwareCommonCtrl.java +++ b/src/main/java/a8k/service/app/devicedriver/commonctrl/HardwareCommonCtrl.java @@ -1,377 +1,377 @@ -package a8k.service.app.devicedriver.commonctrl; - - -import a8k.service.app.devicedriver.basectrl.HbotModule; -import a8k.service.app.devicedriver.basectrl.MiniServoControler; -import a8k.service.app.devicedriver.basectrl.StepMotorControler; -import a8k.service.app.devicedriver.basectrl.type.MiniServoMId; -import a8k.service.app.devicedriver.basectrl.type.StepMotorMId; -import a8k.type.exception.AppException; -import a8k.type.appret.AppRet; -import a8k.extapi_controler.utils.ExtApiTab; -import a8k.extapi_controler.utils.ExtApiFn; -import a8k.extapi_controler.pagecontrol.ExtApiTabConfig; -import a8k.hardware.A8kCanBusService; -import a8k.hardware.type.a8kcanprotocol.A8kEcode; -import a8k.hardware.type.a8kcanprotocol.IOId; -import a8k.hardware.type.a8kcanprotocol.MId; -import a8k.service.app.devicedriver.param.PosParam; -import a8k.service.app.devicedriver.param.TimeParam; -import jakarta.annotation.Resource; -import org.slf4j.Logger; -import org.springframework.stereotype.Component; - -@Component -@ExtApiTab(cfg = ExtApiTabConfig.HardwareCommonCtrl) -public class HardwareCommonCtrl { - static Logger logger = org.slf4j.LoggerFactory.getLogger(HardwareCommonCtrl.class); - - static class ORDER { - static final int initializeDevice = 1; - static final int deviceClear = 2; - static final int deviceForceStop = 3; - static final int forceDisableAllMOtor = 4; - static final int deviceEnable = 5; - } - - @Resource - A8kCanBusService canBus; - @Resource - MiniServoControler miniServoControler; - - @Resource - TimeParam timep; - - @Resource - PosParam posp; - - Boolean workState = false; - - @Resource - HbotModule hbotModule; - - @Resource - StepMotorControler stepMotorControler; - - // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - // CHECK - // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - - private void checkDeviceStateBeforeRunToZero() throws AppException { - logger.info("checkDeviceStateBeforeRunToZero"); - //试管平移通道是否有障碍 - if (canBus.getIOState(IOId.THChInterPPS) || canBus.getIOState(IOId.THChOuterPPS)) { - logger.warn("THChInterPPS or THChOuterPPS is trigger"); - throw new AppException(A8kEcode.APPE_TUBE_X_CHANNEL_IS_NOT_EMPTY); - } - - //板夹仓盖子是否盖上 - if (!canBus.getIOState(IOId.PlateBoxCoverClosurePPS)) { - throw new AppException(A8kEcode.APPE_PLATE_BOX_NOT_COVER); - } - - //板夹仓卡板检测 - if (canBus.getIOState(IOId.PlateBoxPlateStuckPPS)) { - throw new AppException(A8kEcode.APPE_PLATE_STUCK_DETECTOR_SENSOR_TRIGGER); - } - - //检查钩板电机是否处于终点位置 - if (!canBus.getIOState(IOId.PullerMZeroPPS)) { - throw new AppException(A8kEcode.APPE_PULLERM_INIT_POS_ERROR); - } - - //检查板夹仓光电是否处于起点位置 - if (!canBus.getIOState(IOId.PusherMZeroPPS)) { - throw new AppException(A8kEcode.APPE_PUSHERM_INIT_POS_ERROR); - } - //板夹仓光电 - if (canBus.getIOState(IOId.RecycleBinOverflowPPS)) { - throw new AppException(A8kEcode.APPE_PLATE_BOX_NOT_COVER); - } - } - - - private void moveMotorToZero() throws AppException { - - //进出料初始化 - stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.FeedingModXM, timep.getRuntoZeroActionOvertime()); - - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModTubeScanerClampingSV, 20, timep.getActionOvertime()); - - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, 300, timep.getActionOvertime()); - - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperYSV, 300, timep.getActionOvertime()); - - - stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModClampingM, timep.getRuntoZeroActionOvertime()); - stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModGripperZM, timep.getRuntoZeroActionOvertime()); - stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModShakeM, timep.getRuntoZeroActionOvertime()); - - stepMotorControler.stepMotorEasyMoveTo(StepMotorMId.ShakeModShakeM, 90); - - //板夹仓初始化 - stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.PlatesBoxYM, timep.getRuntoZeroActionOvertime()); - stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.PlatesBoxPusherM, timep.getRuntoZeroActionOvertime()); - //光学模组初始化 - stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.OptModPullM, timep.getRuntoZeroActionOvertime()); - stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.OptModScannerM, timep.getRuntoZeroActionOvertime()); - //HBot初始化 - hbotModule.moveToZeroBlock(); - - // TODO stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.PipetteModZM, timep.getRuntoZeroActionOvertime()); - //转盘归零 - stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.IncubatorRotateCtrlM, timep.getRuntoZeroActionOvertime()); - } - - // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - // Expose API - // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @ExtApiFn(name = "设备初始化", order = ORDER.initializeDevice) - public void initializeDevice() throws AppException { - logger.info("Initializing device ..."); - boolean initSuc = false; - workState = true; - AppRet ecode; - try { - //打开必要的电源 - canBus.setIOState(IOId.RecycleBinOverflowPPSPowerCtrl, true); - - //检查设备状态 - checkDeviceStateBeforeRunToZero(); - - // 复位设备 - logger.info("moveMotorToZero"); - moveMotorToZero(); - - initSuc = true; - logger.info("Device initialization completed"); - - } finally { - if (!initSuc) { - try { - stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModClampingM, 1); - } catch (AppException ignored) { - } - try { - stepMotorControler.stepMotorEasyMoveBy(StepMotorMId.ShakeModClampingM, 2); - } catch (AppException ignored) { - } - } - } - - } - - // @EnginnerPageAction(name = "清空板夹仓板夹", order = ORDER.deviceClear) - // public void clearDevice() { - // //TODO - // } - - - @ExtApiFn(name = "设备强制停止", order = ORDER.deviceForceStop) - public void deviceForceStop() throws AppException { - //StopAllMotor - //进出料初始化 - try { - canBus.moduleStop(MId.FeedingModInfeedM); - } catch (AppException ignored) { - } - try { - canBus.moduleStop(MId.FeedingModXM); - } catch (AppException ignored) { - } - try { - canBus.moduleStop(MId.FeedingModOutfeedM); - } catch (AppException ignored) { - } - //摇匀模组初始化 - try { - canBus.moduleStop(MId.ShakeModClampingM); - } catch (AppException ignored) { - } - try { - canBus.moduleStop(MId.ShakeModGripperZM); - } catch (AppException ignored) { - } - try { - canBus.moduleStop(MId.ShakeModShakeM); - } catch (AppException ignored) { - } - try { - canBus.moduleStop(MId.ShakeModGripperYSV); - } catch (AppException ignored) { - } - try { - canBus.moduleStop(MId.ShakeModGripperSV); - } catch (AppException ignored) { - } - try { - canBus.moduleStop(MId.ShakeModTubeScanerClampingSV); - } catch (AppException ignored) { - } - try { - canBus.moduleStop(MId.ShakeModTubeScanerRotateSV); - } catch (AppException ignored) { - } - //板夹仓初始化 - try { - canBus.moduleStop(MId.PlatesBoxYM); - } catch (AppException ignored) { - } - try { - canBus.moduleStop(MId.PlatesBoxPusherM); - } catch (AppException ignored) { - } - //光学模组初始化 - try { - canBus.moduleStop(MId.OptModPullM); - } catch (AppException ignored) { - } - try { - canBus.moduleStop(MId.OptModScannerM); - } catch (AppException ignored) { - } - //HBot初始化 - try { - canBus.moduleStop(MId.HbotM); - } catch (AppException ignored) { - } - // try { - // TODO canBus.moduleStop(MId.PipetteModZM); - // } catch (HardwareException ignored) { - // } - //转盘归零 - try { - canBus.moduleStop(MId.IncubatorRotateCtrlM); - } catch (AppException ignored) { - } - - } - - // @ExtApiFn(name = "设备强制使能所有电机", order = ORDER.forceDisableAllMOtor) - // public void forceDisableAllMOtor() { - // //Disable all motor - // //进出料初始化 - // try { - // stepMotorControler.stepMotorEnable(StepMotorMId.FeedingModInfeedM, 0); - // } catch (AppException ignored) { - // } - // try { - // stepMotorControler.stepMotorEnable(StepMotorMId.FeedingModXM, 0); - // } catch (AppException ignored) { - // } - // try { - // stepMotorControler.stepMotorEnable(StepMotorMId.FeedingModOutfeedM, 0); - // } catch (AppException ignored) { - // } - // - // //摇匀模组初始化 - // try { - // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModClampingM, 0); - // } catch (AppException ignored) { - // } - // try { - // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModGripperZM, 0); - // } catch (AppException ignored) { - // } - // try { - // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModShakeM, 0); - // } catch (AppException ignored) { - // } - // try { - // canBus.miniServoEnable(MId.ShakeModGripperYSV, 0); - // } catch (AppException ignored) { - // } - // try { - // canBus.miniServoEnable(MId.ShakeModGripperSV, 0); - // } catch (AppException ignored) { - // } - // try { - // canBus.miniServoEnable(MId.ShakeModTubeScanerClampingSV, 0); - // } catch (AppException ignored) { - // } - // try { - // canBus.miniServoEnable(MId.ShakeModTubeScanerRotateSV, 0); - // } catch (AppException ignored) { - // } - // - // //板夹仓初始化 - // try { - // stepMotorControler.stepMotorEnable(StepMotorMId.PlatesBoxYM, 0); - // } catch (AppException ignored) { - // } - // try { - // stepMotorControler.stepMotorEnable(StepMotorMId.PlatesBoxPusherM, 0); - // } catch (AppException ignored) { - // } - // - // //光学模组初始化 - // try { - // stepMotorControler.stepMotorEnable(StepMotorMId.OptModPullM, 0); - // } catch (AppException ignored) { - // } - // try { - // stepMotorControler.stepMotorEnable(StepMotorMId.OptModScannerM, 0); - // } catch (AppException ignored) { - // } - // - // //HBot初始化 - // try { - // canBus.hbotEnable(MId.HbotM, 0); - // } catch (AppException ignored) { - // } - // // try { - // //TODO stepMotorControler.stepMotorEnable(StepMotorMId.PipetteModZM, 0); - // // } catch (HardwareException ignored) { - // // } - // - // //转盘归零 - // try { - // stepMotorControler.stepMotorEnable(StepMotorMId.IncubatorRotateCtrlM, 0); - // } catch (AppException ignored) { - // } - // } - - // @ExtApiFn(name = "设备使能", order = ORDER.deviceEnable) - // public void deviceEnable(Boolean enable) throws AppException { - // //进出料初始化 - // stepMotorControler.stepMotorEnable(StepMotorMId.FeedingModInfeedM, enable ? 1 : 0); - // stepMotorControler.stepMotorEnable(StepMotorMId.FeedingModXM, enable ? 1 : 0); - // stepMotorControler.stepMotorEnable(StepMotorMId.FeedingModOutfeedM, enable ? 1 : 0); - // - // //摇匀模组初始化 - // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModClampingM, enable ? 1 : 0); - // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModGripperZM, enable ? 1 : 0); - // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModShakeM, enable ? 1 : 0); - // canBus.miniServoEnable(MId.ShakeModGripperYSV, enable ? 1 : 0); - // canBus.miniServoEnable(MId.ShakeModGripperSV, enable ? 1 : 0); - // canBus.miniServoEnable(MId.ShakeModTubeScanerClampingSV, enable ? 1 : 0); - // canBus.miniServoEnable(MId.ShakeModTubeScanerRotateSV, enable ? 1 : 0); - // - // //板夹仓初始化 - // stepMotorControler.stepMotorEnable(StepMotorMId.PlatesBoxYM, enable ? 1 : 0); - // stepMotorControler.stepMotorEnable(StepMotorMId.PlatesBoxPusherM, enable ? 1 : 0); - // - // //光学模组初始化 - // stepMotorControler.stepMotorEnable(StepMotorMId.OptModPullM, enable ? 1 : 0); - // stepMotorControler.stepMotorEnable(StepMotorMId.OptModScannerM, enable ? 1 : 0); - // - // //HBot初始化 - // canBus.hbotEnable(MId.HbotM, enable ? 1 : 0); - // // TODO stepMotorControler.stepMotorEnable(StepMotorMId.PipetteModZM, enable ? 1 : 0); - // - // //转盘归零 - // stepMotorControler.stepMotorEnable(StepMotorMId.IncubatorRotateCtrlM, enable ? 1 : 0); - // } - // - // public void checkBeforeMove(MId mId) throws AppException { - // //板夹仓盖子是否盖上 - // if (!canBus.getIOState(IOId.PlateBoxCoverClosurePPS)) { - // throw new AppException(A8kEcode.APPE_PLATE_BOX_NOT_COVER); - // } - // } - - public void stop() { - workState = false; - } - -} +//package a8k.service.app.devicedriver.commonctrl; +// +// +//import a8k.service.app.devicedriver.basectrl.HbotModule; +//import a8k.service.app.devicedriver.basectrl.MiniServoControler; +//import a8k.service.app.devicedriver.basectrl.StepMotorControler; +//import a8k.service.app.devicedriver.basectrl.type.MiniServoMId; +//import a8k.service.app.devicedriver.basectrl.type.StepMotorMId; +//import a8k.type.exception.AppException; +//import a8k.type.appret.AppRet; +//import a8k.extapi_controler.utils.ExtApiTab; +//import a8k.extapi_controler.utils.ExtApiFn; +//import a8k.extapi_controler.pagecontrol.ExtApiTabConfig; +//import a8k.hardware.A8kCanBusService; +//import a8k.hardware.type.a8kcanprotocol.A8kEcode; +//import a8k.hardware.type.a8kcanprotocol.IOId; +//import a8k.hardware.type.a8kcanprotocol.MId; +//import a8k.service.app.devicedriver.param.PosParam; +//import a8k.service.app.devicedriver.param.TimeParam; +//import jakarta.annotation.Resource; +//import org.slf4j.Logger; +//import org.springframework.stereotype.Component; +// +//@Component +//@ExtApiTab(cfg = ExtApiTabConfig.HardwareCommonCtrl) +//public class HardwareCommonCtrl { +// static Logger logger = org.slf4j.LoggerFactory.getLogger(HardwareCommonCtrl.class); +// +// static class ORDER { +// static final int initializeDevice = 1; +// static final int deviceClear = 2; +// static final int deviceForceStop = 3; +// static final int forceDisableAllMOtor = 4; +// static final int deviceEnable = 5; +// } +// +// @Resource +// A8kCanBusService canBus; +// @Resource +// MiniServoControler miniServoControler; +// +// @Resource +// TimeParam timep; +// +// @Resource +// PosParam posp; +// +// Boolean workState = false; +// +// @Resource +// HbotModule hbotModule; +// +// @Resource +// StepMotorControler stepMotorControler; +// +// // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// // CHECK +// // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// +// private void checkDeviceStateBeforeRunToZero() throws AppException { +// logger.info("checkDeviceStateBeforeRunToZero"); +// //试管平移通道是否有障碍 +// if (canBus.getIOState(IOId.THChInterPPS) || canBus.getIOState(IOId.THChOuterPPS)) { +// logger.warn("THChInterPPS or THChOuterPPS is trigger"); +// throw new AppException(A8kEcode.APPE_TUBE_X_CHANNEL_IS_NOT_EMPTY); +// } +// +// //板夹仓盖子是否盖上 +// if (!canBus.getIOState(IOId.PlateBoxCoverClosurePPS)) { +// throw new AppException(A8kEcode.APPE_PLATE_BOX_NOT_COVER); +// } +// +// //板夹仓卡板检测 +// if (canBus.getIOState(IOId.PlateBoxPlateStuckPPS)) { +// throw new AppException(A8kEcode.APPE_PLATE_STUCK_DETECTOR_SENSOR_TRIGGER); +// } +// +// //检查钩板电机是否处于终点位置 +// if (!canBus.getIOState(IOId.PullerMZeroPPS)) { +// throw new AppException(A8kEcode.APPE_PULLERM_INIT_POS_ERROR); +// } +// +// //检查板夹仓光电是否处于起点位置 +// if (!canBus.getIOState(IOId.PusherMZeroPPS)) { +// throw new AppException(A8kEcode.APPE_PUSHERM_INIT_POS_ERROR); +// } +// //板夹仓光电 +// if (canBus.getIOState(IOId.RecycleBinOverflowPPS)) { +// throw new AppException(A8kEcode.APPE_PLATE_BOX_NOT_COVER); +// } +// } +// +// +// private void moveMotorToZero() throws AppException { +// +// //进出料初始化 +// stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.FeedingModXM, timep.getRuntoZeroActionOvertime()); +// +// miniServoControler.miniServoMoveToZeroBlock(MiniServoMId.ShakeModTubeScanerClampingSV); +// +// miniServoControler.miniServoMoveToZeroBlock(MiniServoMId.ShakeModGripperSV); +// +// miniServoControler.miniServoMoveToZeroBlock(MiniServoMId.ShakeModGripperYSV); +// +// +// stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModClampingM, timep.getRuntoZeroActionOvertime()); +// stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModGripperZM, timep.getRuntoZeroActionOvertime()); +// stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModShakeM, timep.getRuntoZeroActionOvertime()); +// +// stepMotorControler.stepMotorEasyMoveTo(StepMotorMId.ShakeModShakeM, 90); +// +// //板夹仓初始化 +// stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.PlatesBoxYM, timep.getRuntoZeroActionOvertime()); +// stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.PlatesBoxPusherM, timep.getRuntoZeroActionOvertime()); +// //光学模组初始化 +// stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.OptModPullM, timep.getRuntoZeroActionOvertime()); +// stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.OptModScannerM, timep.getRuntoZeroActionOvertime()); +// //HBot初始化 +// hbotModule.moveToZeroBlock(); +// +// // TODO stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.PipetteModZM, timep.getRuntoZeroActionOvertime()); +// //转盘归零 +// stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.IncubatorRotateCtrlM, timep.getRuntoZeroActionOvertime()); +// } +// +// // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// // Expose API +// // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// @ExtApiFn(name = "设备初始化", order = ORDER.initializeDevice) +// public void initializeDevice() throws AppException { +// logger.info("Initializing device ..."); +// boolean initSuc = false; +// workState = true; +// AppRet ecode; +// try { +// //打开必要的电源 +// canBus.setIOState(IOId.RecycleBinOverflowPPSPowerCtrl, true); +// +// //检查设备状态 +// checkDeviceStateBeforeRunToZero(); +// +// // 复位设备 +// logger.info("moveMotorToZero"); +// moveMotorToZero(); +// +// initSuc = true; +// logger.info("Device initialization completed"); +// +// } finally { +// if (!initSuc) { +// try { +// stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModClampingM, 1); +// } catch (AppException ignored) { +// } +// try { +// stepMotorControler.stepMotorEasyMoveBy(StepMotorMId.ShakeModClampingM, 2); +// } catch (AppException ignored) { +// } +// } +// } +// +// } +// +// // @EnginnerPageAction(name = "清空板夹仓板夹", order = ORDER.deviceClear) +// // public void clearDevice() { +// // //TODO +// // } +// +// +// @ExtApiFn(name = "设备强制停止", order = ORDER.deviceForceStop) +// public void deviceForceStop() throws AppException { +// //StopAllMotor +// //进出料初始化 +// try { +// canBus.moduleStop(MId.FeedingModInfeedM); +// } catch (AppException ignored) { +// } +// try { +// canBus.moduleStop(MId.FeedingModXM); +// } catch (AppException ignored) { +// } +// try { +// canBus.moduleStop(MId.FeedingModOutfeedM); +// } catch (AppException ignored) { +// } +// //摇匀模组初始化 +// try { +// canBus.moduleStop(MId.ShakeModClampingM); +// } catch (AppException ignored) { +// } +// try { +// canBus.moduleStop(MId.ShakeModGripperZM); +// } catch (AppException ignored) { +// } +// try { +// canBus.moduleStop(MId.ShakeModShakeM); +// } catch (AppException ignored) { +// } +// try { +// canBus.moduleStop(MId.ShakeModGripperYSV); +// } catch (AppException ignored) { +// } +// try { +// canBus.moduleStop(MId.ShakeModGripperSV); +// } catch (AppException ignored) { +// } +// try { +// canBus.moduleStop(MId.ShakeModTubeScanerClampingSV); +// } catch (AppException ignored) { +// } +// try { +// canBus.moduleStop(MId.ShakeModTubeScanerRotateSV); +// } catch (AppException ignored) { +// } +// //板夹仓初始化 +// try { +// canBus.moduleStop(MId.PlatesBoxYM); +// } catch (AppException ignored) { +// } +// try { +// canBus.moduleStop(MId.PlatesBoxPusherM); +// } catch (AppException ignored) { +// } +// //光学模组初始化 +// try { +// canBus.moduleStop(MId.OptModPullM); +// } catch (AppException ignored) { +// } +// try { +// canBus.moduleStop(MId.OptModScannerM); +// } catch (AppException ignored) { +// } +// //HBot初始化 +// try { +// canBus.moduleStop(MId.HbotM); +// } catch (AppException ignored) { +// } +// // try { +// // TODO canBus.moduleStop(MId.PipetteModZM); +// // } catch (HardwareException ignored) { +// // } +// //转盘归零 +// try { +// canBus.moduleStop(MId.IncubatorRotateCtrlM); +// } catch (AppException ignored) { +// } +// +// } +// +// // @ExtApiFn(name = "设备强制使能所有电机", order = ORDER.forceDisableAllMOtor) +// // public void forceDisableAllMOtor() { +// // //Disable all motor +// // //进出料初始化 +// // try { +// // stepMotorControler.stepMotorEnable(StepMotorMId.FeedingModInfeedM, 0); +// // } catch (AppException ignored) { +// // } +// // try { +// // stepMotorControler.stepMotorEnable(StepMotorMId.FeedingModXM, 0); +// // } catch (AppException ignored) { +// // } +// // try { +// // stepMotorControler.stepMotorEnable(StepMotorMId.FeedingModOutfeedM, 0); +// // } catch (AppException ignored) { +// // } +// // +// // //摇匀模组初始化 +// // try { +// // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModClampingM, 0); +// // } catch (AppException ignored) { +// // } +// // try { +// // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModGripperZM, 0); +// // } catch (AppException ignored) { +// // } +// // try { +// // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModShakeM, 0); +// // } catch (AppException ignored) { +// // } +// // try { +// // canBus.miniServoEnable(MId.ShakeModGripperYSV, 0); +// // } catch (AppException ignored) { +// // } +// // try { +// // canBus.miniServoEnable(MId.ShakeModGripperSV, 0); +// // } catch (AppException ignored) { +// // } +// // try { +// // canBus.miniServoEnable(MId.ShakeModTubeScanerClampingSV, 0); +// // } catch (AppException ignored) { +// // } +// // try { +// // canBus.miniServoEnable(MId.ShakeModTubeScanerRotateSV, 0); +// // } catch (AppException ignored) { +// // } +// // +// // //板夹仓初始化 +// // try { +// // stepMotorControler.stepMotorEnable(StepMotorMId.PlatesBoxYM, 0); +// // } catch (AppException ignored) { +// // } +// // try { +// // stepMotorControler.stepMotorEnable(StepMotorMId.PlatesBoxPusherM, 0); +// // } catch (AppException ignored) { +// // } +// // +// // //光学模组初始化 +// // try { +// // stepMotorControler.stepMotorEnable(StepMotorMId.OptModPullM, 0); +// // } catch (AppException ignored) { +// // } +// // try { +// // stepMotorControler.stepMotorEnable(StepMotorMId.OptModScannerM, 0); +// // } catch (AppException ignored) { +// // } +// // +// // //HBot初始化 +// // try { +// // canBus.hbotEnable(MId.HbotM, 0); +// // } catch (AppException ignored) { +// // } +// // // try { +// // //TODO stepMotorControler.stepMotorEnable(StepMotorMId.PipetteModZM, 0); +// // // } catch (HardwareException ignored) { +// // // } +// // +// // //转盘归零 +// // try { +// // stepMotorControler.stepMotorEnable(StepMotorMId.IncubatorRotateCtrlM, 0); +// // } catch (AppException ignored) { +// // } +// // } +// +// // @ExtApiFn(name = "设备使能", order = ORDER.deviceEnable) +// // public void deviceEnable(Boolean enable) throws AppException { +// // //进出料初始化 +// // stepMotorControler.stepMotorEnable(StepMotorMId.FeedingModInfeedM, enable ? 1 : 0); +// // stepMotorControler.stepMotorEnable(StepMotorMId.FeedingModXM, enable ? 1 : 0); +// // stepMotorControler.stepMotorEnable(StepMotorMId.FeedingModOutfeedM, enable ? 1 : 0); +// // +// // //摇匀模组初始化 +// // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModClampingM, enable ? 1 : 0); +// // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModGripperZM, enable ? 1 : 0); +// // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModShakeM, enable ? 1 : 0); +// // canBus.miniServoEnable(MId.ShakeModGripperYSV, enable ? 1 : 0); +// // canBus.miniServoEnable(MId.ShakeModGripperSV, enable ? 1 : 0); +// // canBus.miniServoEnable(MId.ShakeModTubeScanerClampingSV, enable ? 1 : 0); +// // canBus.miniServoEnable(MId.ShakeModTubeScanerRotateSV, enable ? 1 : 0); +// // +// // //板夹仓初始化 +// // stepMotorControler.stepMotorEnable(StepMotorMId.PlatesBoxYM, enable ? 1 : 0); +// // stepMotorControler.stepMotorEnable(StepMotorMId.PlatesBoxPusherM, enable ? 1 : 0); +// // +// // //光学模组初始化 +// // stepMotorControler.stepMotorEnable(StepMotorMId.OptModPullM, enable ? 1 : 0); +// // stepMotorControler.stepMotorEnable(StepMotorMId.OptModScannerM, enable ? 1 : 0); +// // +// // //HBot初始化 +// // canBus.hbotEnable(MId.HbotM, enable ? 1 : 0); +// // // TODO stepMotorControler.stepMotorEnable(StepMotorMId.PipetteModZM, enable ? 1 : 0); +// // +// // //转盘归零 +// // stepMotorControler.stepMotorEnable(StepMotorMId.IncubatorRotateCtrlM, enable ? 1 : 0); +// // } +// // +// // public void checkBeforeMove(MId mId) throws AppException { +// // //板夹仓盖子是否盖上 +// // if (!canBus.getIOState(IOId.PlateBoxCoverClosurePPS)) { +// // throw new AppException(A8kEcode.APPE_PLATE_BOX_NOT_COVER); +// // } +// // } +// +// public void stop() { +// workState = false; +// } +// +//} diff --git a/src/main/java/a8k/service/app/devicedriver/ctrl/DeviceInitCtrlService.java b/src/main/java/a8k/service/app/devicedriver/ctrl/DeviceInitCtrlService.java index f5837a0..43d0a4b 100644 --- a/src/main/java/a8k/service/app/devicedriver/ctrl/DeviceInitCtrlService.java +++ b/src/main/java/a8k/service/app/devicedriver/ctrl/DeviceInitCtrlService.java @@ -36,9 +36,9 @@ public class DeviceInitCtrlService { @Resource AppDebugHelperService appDebugHelper; @Resource - MiniServoControler miniServoControler; + MiniServoControler miniServoControler; @Resource - StepMotorControler stepMotorControler; + StepMotorControler stepMotorControler; Integer actionOvertime = 10000; List checkPoints = new ArrayList<>(); @@ -94,9 +94,9 @@ public class DeviceInitCtrlService { //进出料初始化 actionReactor.dosome("入料平移电机回零", () -> stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.FeedingModXM, actionOvertime)); - actionReactor.dosome("摇匀模组-扫码夹紧舵机回零", () -> miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModTubeScanerClampingSV, 20, actionOvertime)); - actionReactor.dosome("摇匀模组-夹爪舵机回零", () -> miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, 300, actionOvertime)); - actionReactor.dosome("摇匀模组-夹爪Y轴舵机回零", () -> miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperYSV, 300, actionOvertime)); + actionReactor.dosome("摇匀模组-扫码夹紧舵机回零", () -> miniServoControler.miniServoMoveToZeroBlock(MiniServoMId.ShakeModTubeScanerClampingSV)); + actionReactor.dosome("摇匀模组-夹爪舵机回零", () -> miniServoControler.miniServoMoveToZeroBlock(MiniServoMId.ShakeModGripperSV)); + actionReactor.dosome("摇匀模组-夹爪Y轴舵机回零", () -> miniServoControler.miniServoMoveToZeroBlock(MiniServoMId.ShakeModGripperYSV)); actionReactor.dosome("摇匀模组-夹紧电机回零", () -> stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModClampingM, actionOvertime)); actionReactor.dosome("摇匀模组-夹爪Z轴电机回零", () -> stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModGripperZM, actionOvertime)); actionReactor.dosome("摇匀模组-摇匀电机回零", () -> stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModShakeM, actionOvertime)); diff --git a/src/main/java/a8k/service/app/devicedriver/ctrl/TubePreProcesControler.java b/src/main/java/a8k/service/app/devicedriver/ctrl/TubePreProcesControler.java index 4e40a6e..1d4c6ea 100644 --- a/src/main/java/a8k/service/app/devicedriver/ctrl/TubePreProcesControler.java +++ b/src/main/java/a8k/service/app/devicedriver/ctrl/TubePreProcesControler.java @@ -1,5 +1,6 @@ package a8k.service.app.devicedriver.ctrl; +import a8k.constant.MiniServoConstant; import a8k.extapi_controler.pagecontrol.ExtApiTabConfig; import a8k.extapi_controler.utils.ExtApiFn; import a8k.extapi_controler.utils.ExtApiTab; @@ -12,9 +13,6 @@ import a8k.type.exception.AppException; import a8k.hardware.A8kCanBusService; import a8k.hardware.type.a8kcanprotocol.A8kEcode; import a8k.hardware.type.a8kcanprotocol.MId; -import a8k.service.app.devicedriver.param.DebugParam; -import a8k.service.app.devicedriver.param.TimeParam; -import a8k.service.app.devicedriver.param.PosParam; import a8k.utils.ZEQ; import jakarta.annotation.Resource; import org.slf4j.Logger; @@ -41,89 +39,137 @@ public class TubePreProcesControler { } @Resource - A8kCanBusService canBus; - @Resource - TimeParam timep; - @Resource - PosParam pp; - @Resource - DebugParam dp; - + A8kCanBusService canBus; @Resource TubePreProcesPosMgr tubePreProcesPosMgr; - @Resource - MiniServoControler miniServoControler; + MiniServoControler miniServoControler; @Resource - StepMotorControler stepMotorControler; + StepMotorControler stepMotorControler; // ++++++++++++++++++++++++++++++++++++++++++++++++++++++ // PRIVATE // ++++++++++++++++++++++++++++++++++++++++++++++++++++++ private void modGroupMoveToZero() throws AppException { - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, pp.getGripperClosePos(), timep.getActionOvertime()); - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperYSV, pp.getGripperZeroYPos(), timep.getActionOvertime()); - stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModClampingM, timep.getActionOvertime()); - stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModGripperZM, timep.getActionOvertime()); - stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModShakeM, timep.getActionOvertime()); - stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModShakeM, 90, timep.getActionOvertime()); - stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModClampingM, -2, timep.getActionOvertime()); + miniServoControler.miniServoMoveToZeroBlock(MiniServoMId.ShakeModGripperSV); + miniServoControler.miniServoMoveToZeroBlock(MiniServoMId.ShakeModGripperYSV); + stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModClampingM, actionOvertime); + stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModGripperZM, actionOvertime); + stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModShakeM, actionOvertime); + stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModShakeM, 90, actionOvertime); } private void modGroupMoveToZeroQuick() throws AppException { - stepMotorControler.stepMotorEasyMoveToZeroPointQuickBlock(StepMotorMId.ShakeModGripperZM, timep.getActionOvertime()); - stepMotorControler.stepMotorEasyMoveToZeroPointQuickBlock(StepMotorMId.ShakeModClampingM, timep.getActionOvertime()); - stepMotorControler.stepMotorEasyMoveToZeroPointQuickBlock(StepMotorMId.ShakeModShakeM, timep.getActionOvertime()); + stepMotorControler.stepMotorEasyMoveToZeroPointQuickBlock(StepMotorMId.ShakeModGripperZM, actionOvertime); + stepMotorControler.stepMotorEasyMoveToZeroPointQuickBlock(StepMotorMId.ShakeModClampingM, actionOvertime); + stepMotorControler.stepMotorEasyMoveToZeroPointQuickBlock(StepMotorMId.ShakeModShakeM, actionOvertime); modGroupMoveToZero(); } - // @ExtApiFn(name = "模块复位", group = "辅助调试", order = ORDER.moduleReset) - // public void moduleReset() throws AppException { - // modGroupMoveToZero(); - // } - // - // @ExtApiFn(name = "模块使能", group = "辅助调试", order = ORDER.moduleEnable) - // public void moduleEnable() throws AppException { - // canBus.miniServoEnable(MId.ShakeModGripperSV, 1); - // canBus.miniServoEnable(MId.ShakeModGripperYSV, 1); - // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModClampingM, 1); - // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModGripperZM, 1); - // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModShakeM, 1); - // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModShakeM, 1); - // } - // - // @ExtApiFn(name = "模块失能", group = "辅助调试", order = ORDER.moduleDisable) - // public void moduleDisable() throws AppException { - // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModClampingM, 1); - // stepMotorControler.stepMotorEasyMoveByBlock(StepMotorMId.ShakeModClampingM, 10, timep.getActionOvertime()); - // + /** + * 气溶胶风扇控制 + */ + @ExtApiFn(name = "气溶胶风扇控制", group = "其他", order = ORDER.setAeroslFanPower) + public void setAeroslFanPower(Boolean enable) throws Exception { + if (enable) { + canBus.fanControlerSetSpeed(MId.WbTubeFanMod, 99); + } else { + canBus.fanControlerSetSpeed(MId.WbTubeFanMod, 0); + } + } + + // Api + + public void gripperSVOpen() throws AppException { + miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, tubePreProcesPosMgr.getGripperServoOpenPos()); + } + + public void gripperSVCClose() throws AppException { + miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, tubePreProcesPosMgr.getGripperServoClosePos()); + } + + public void gripperSVClampTube() throws AppException { + miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, tubePreProcesPosMgr.getGripperServoTakeCapPos()); + } + + + public void YSVMoveToTakeTubePos() throws AppException { + miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperYSV, tubePreProcesPosMgr.getYServoTakeTubePos() - 100); //该动作是为了消除齿轮间隙 + miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperYSV, tubePreProcesPosMgr.getYServoTakeTubePos()); + } + + public void YSVMoveToShakePos() throws AppException { + miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperYSV, tubePreProcesPosMgr.getYServoShakePos() - 100); //该动作是为了消除齿轮间隙 + miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperYSV, tubePreProcesPosMgr.getYServoShakePos()); + } + + public void YSVMoveToStandyPos() throws AppException { + miniServoControler.miniServoMoveToZeroBlock(MiniServoMId.ShakeModGripperYSV); + } + + + public void zMotorMoveToTakeHTubePos() throws AppException { + stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModGripperZM, tubePreProcesPosMgr.getZMotorTakeHTubePos(), actionOvertime); + } + + public void zMotorMoveToShakeTubePos() throws AppException { + stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModGripperZM, tubePreProcesPosMgr.getZMotorShakeTubePos(), actionOvertime); + } + + public void zMotorMoveToZeroQuick() throws AppException { + stepMotorControler.stepMotorEasyMoveToZeroPointQuickBlock(StepMotorMId.ShakeModGripperZM, actionOvertime); + } + + + public void clampingMclampTube() throws AppException { + stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModClampingM, tubePreProcesPosMgr.getShakeClampMotorClampPos(), actionOvertime); + } + + public void clampingMReleaseTube() throws AppException { + stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModClampingM, tubePreProcesPosMgr.getShakeClampMotorReleasePos(), actionOvertime); + } + + public void shakeMMoveTo90() throws AppException { + stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModShakeM, 90, actionOvertime); + } + + public void shakeMShake(Integer shakeDegree, Integer times) throws AppException { + var startPos = 90 - shakeDegree; + var endPos = 90 + shakeDegree; + stepMotorControler.stepMotorEasyReciprocatingMotion(StepMotorMId.ShakeModShakeM, startPos, endPos, times); + canBus.waitForMod(MId.ShakeModShakeM, actionOvertime); + } + // - // canBus.miniServoEnable(MId.ShakeModGripperSV, 0); - // canBus.miniServoEnable(MId.ShakeModGripperYSV, 0); - // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModClampingM, 0); - // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModGripperZM, 0); - // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModShakeM, 0); - // stepMotorControler.stepMotorEnable(StepMotorMId.ShakeModShakeM, 0); - // } + //Script // - // @ExtApiFn(name = "夹紧试管", group = "辅助调试", order = ORDER.moduleDisable) - // public void clampTube() throws AppException { - // stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModClampingM, pp.getShakeClampingPos(), timep.getActionOvertime()); - // } + public void takeTubeFromTubeholder() throws AppException { + //打开夹爪 + gripperSVOpen(); + //Z轴下移动到取试管位置 + zMotorMoveToTakeHTubePos(); + //夹爪夹紧 + gripperSVClampTube(); + //Z轴快速归零 + zMotorMoveToZeroQuick(); + } - void tryClampTube() throws AppException { - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, pp.getGripperTakeCapPos() - 20, timep.getActionOvertime()); - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, pp.getGripperTakeCapPos(), timep.getActionOvertime()); - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, pp.getGripperTakeCapPos() - 20, timep.getActionOvertime()); + public void putTubeToTubeholder() throws AppException { + YSVMoveToTakeTubePos(); + //Z轴下移动到取试管位置 + stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModGripperZM, tubePreProcesPosMgr.getZMotorTakeHTubePos() - 100, actionOvertime); + //打开夹爪 + gripperSVOpen(); + //Z轴快速归零 + zMotorMoveToZeroQuick(); } + /** - * 取试管帽,如果试管帽存在， - * @param highTube true/false + * 取试管帽,并放置在摇匀位 */ - @ExtApiFn(name = "取试管", group = "单步", order = ORDER.takeTubeAndJudgeTubeExist) - public Boolean takeTubeAndJudgeTubeExist(Boolean highTube) throws AppException { + public void takeTubeFromTubeholderToShakePos() throws AppException { /* * 校验: * 1.当前摇匀模组设计到的电机是否都处于待机位 @@ -135,166 +181,86 @@ public class TubePreProcesControler { } //Y轴在零点附近 - if (!ZEQ.IntEq(miniServoControler.miniServoReadPos(MiniServoMId.ShakeModGripperYSV), pp.getGripperZeroYPos(), 30)) { + if (!ZEQ.IntEq(miniServoControler.miniServoReadPos(MiniServoMId.ShakeModGripperYSV), MiniServoConstant.getZeroPos(MiniServoMId.ShakeModGripperYSV), 30)) { throw new AppException(A8kEcode.CODEERROR_MOTOR_NOT_IN_ZERO_POS, MId.ShakeModGripperYSV); } //夹爪没有零位置 - if (!ZEQ.IntEq(miniServoControler.miniServoReadPos(MiniServoMId.ShakeModGripperSV), pp.getGripperClosePos(), 30)) { + if (!ZEQ.IntEq(miniServoControler.miniServoReadPos(MiniServoMId.ShakeModGripperSV), MiniServoConstant.getZeroPos(MiniServoMId.ShakeModGripperSV), 30)) { throw new AppException(A8kEcode.CODEERROR_MOTOR_NOT_IN_ZERO_POS, MId.ShakeModGripperSV); } - //检查摇匀夹紧是否在零位 + // 检查摇匀夹紧是否在零位 if (!stepMotorControler.stepMotorReadIoState(StepMotorMId.ShakeModClampingM, 0)) { throw new AppException(A8kEcode.CODEERROR_MOTOR_NOT_IN_ZERO_POS, MId.ShakeModClampingM); } - boolean isHighBlood = highTube; - boolean tubeCapExist = true; - Integer gripperJudgeCapZPos = isHighBlood ? pp.getGripperJudgeHTubeCapZPos() : pp.getGripperJudgeSTubeCapZPos(); - Integer gripperTakeTubeZPos = isHighBlood ? pp.getGripperTakeHTubeZPos() : pp.getGripperTakeSTubeZPos(); - Integer gripperShakeZPos = pp.getGripperShakeTubeZPos(); - - //固定试管架 - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModTubeScanerClampingSV, 900, timep.getActionOvertime()); + // + // Reset some motor + // //试管夹紧移动到终点位置 - stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModClampingM, 70, timep.getActionOvertime()); + clampingMReleaseTube(); //试管摇匀移动到90度 - stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModShakeM, pp.getShakeModShakeMStandbyPos(), timep.getActionOvertime()); - //Y轴向前移动 - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperYSV, pp.getGripperTakeTubeYPos(), timep.getActionOvertime()); - //打开夹爪 - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, pp.getGripperOpenPos(), timep.getActionOvertime()); - // //Z轴下移动到试管帽有无检测位 - // stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModGripperZM, gripperJudgeCapZPos, timep.getActionOvertime()); - // 闭合夹爪检测试管帽是否存在 - // miniServoControler.miniServoRotateWithTorque(MiniServoMid.ShakeModGripperSV, -400); - // Thread.sleep(timep.getTubeCapJudgeDelayTime()); - // if (ZEQ.IntEq(miniServoControler.miniServoReadPos(MiniServoMid.ShakeModGripperSV), pp.getGripperClosePos(), 30)) { - // logger.info("试管帽不存在"); - // tubeCapExist = false; - // } - if (dp.getDebugMode() || tubeCapExist) { - //打开夹爪 - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, pp.getGripperOpenPos(), timep.getActionOvertime()); - //Z轴下移动到取试管位置 - stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModGripperZM, gripperTakeTubeZPos, timep.getActionOvertime()); - //夹爪夹紧 - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, pp.getGripperTakeCapPos(), timep.getActionOvertime()); - stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModGripperZM, gripperTakeTubeZPos - 100, timep.getActionOvertime()); - tryClampTube(); - - //Z轴上移动到零位 - stepMotorControler.stepMotorEasyMoveToZeroPointQuickBlock(StepMotorMId.ShakeModGripperZM, timep.getActionOvertime()); - //夹爪夹紧 - //Y轴移动到摇匀位 - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperYSV, pp.getGripperShakeYPos() - 50, timep.getActionOvertime()); //该动作是为了消除齿轮间隙 - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperYSV, pp.getGripperShakeYPos(), timep.getActionOvertime()); - //Z轴下移动到摇匀位放试管的位置 - stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModGripperZM, gripperShakeZPos, timep.getActionOvertime()); - //夹紧试管 - stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModClampingM, pp.getShakeClampingPos(), timep.getActionOvertime()); - //松开夹爪，放置试管 - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, pp.getGripperOpenPos(), timep.getActionOvertime()); - //Z轴上移动到零位 - stepMotorControler.stepMotorEasyMoveToZeroPointQuickBlock(StepMotorMId.ShakeModGripperZM, timep.getActionOvertime()); - //Z轴归零,校准一次位置 - stepMotorControler.stepMotorEasyMoveToZeroBlock(StepMotorMId.ShakeModGripperZM, timep.getActionOvertime()); - //Y轴移动到零位 - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperYSV, pp.getGripperZeroYPos(), timep.getActionOvertime()); - } else { - modGroupMoveToZeroQuick(); - } - return tubeCapExist; + shakeMMoveTo90(); + + // + //Y轴移动到取试管位置 + YSVMoveToTakeTubePos(); + //取试管 + takeTubeFromTubeholder(); + //Y轴移动到摇匀位 + YSVMoveToShakePos(); + //Z轴下移动到摇匀位放试管的位置 + zMotorMoveToShakeTubePos(); + //夹紧试管 + clampingMclampTube(); + //松开夹爪，放置试管 + gripperSVOpen(); + //Z轴上移动到零位 + zMotorMoveToZeroQuick(); + //Y轴移动到零位 + YSVMoveToStandyPos(); } - @ExtApiFn(name = "摇匀", group = "单步", order = ORDER.shakeTube) public void shakeTube(Integer shakeDegree, Integer times) throws AppException { - var standByPos = pp.getShakeModShakeMStandbyPos(); - var startPos = standByPos - shakeDegree; - var endPos = standByPos + shakeDegree; - stepMotorControler.stepMotorEasyReciprocatingMotion(StepMotorMId.ShakeModShakeM, startPos, endPos, times); - canBus.waitForMod(MId.ShakeModShakeM, timep.getActionOvertime()); + shakeMShake(shakeDegree, times); } - @ExtApiFn(name = "取试管帽", group = "单步", order = ORDER.takeTubeCap) public void takeTubeCap() throws AppException { //Y移动到取试管帽位置 - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperYSV, pp.getGripperShakeYPos(), timep.getActionOvertime()); - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, pp.getGripperOpenPos(), timep.getActionOvertime()); + YSVMoveToShakePos(); //Z下移动到取试管帽位置 - stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModGripperZM, pp.getGripperTakeCapZPos() + 3, timep.getActionOvertime()); + zMotorMoveToShakeTubePos(); //闭合夹爪 - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, pp.getGripperTakeCapPos(), timep.getActionOvertime()); + gripperSVClampTube(); //Z上移动到零位 - stepMotorControler.stepMotorEasyMoveToZeroPointQuickBlock(StepMotorMId.ShakeModGripperZM, timep.getActionOvertime()); - // tryClampTube(); - // miniServoControler.miniServoMoveToBlock(MiniServoMid.ShakeModGripperSV, pp.getGripperTakeCapPos()-30, timep.getActionOvertime()); - - + zMotorMoveToZeroQuick(); //Y移动到待机位 - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperYSV, pp.getGripperZeroYPos(), timep.getActionOvertime()); + YSVMoveToStandyPos(); } - /** - * 盖试管帽，并将试管移动回试管架中 - */ - @ExtApiFn(name = "盖试管帽并放回试管架", group = "单步", order = ORDER.pushBackTubeCapAndTakeBakTube) - public void pushBackTubeCapAndTakeBakTube() throws AppException { - //移动Y轴到取试管帽位置 - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperYSV, pp.getGripperShakeYPos(), timep.getActionOvertime()); - //移动Z轴盖帽 - stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModGripperZM, pp.getGripperTakeCapZPos() + 20, timep.getActionOvertime()); - //打开试管夹 - stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModClampingM, 70, timep.getActionOvertime()); - //移动Z轴到零位 - stepMotorControler.stepMotorEasyMoveToZeroPointQuickBlock(StepMotorMId.ShakeModGripperZM, timep.getActionOvertime()); - - tryClampTube(); + public void putbakTubeCapAndPutbakTubeToTubeHolder() throws AppException { + //移动Y轴到方式管的位置 + YSVMoveToShakePos(); +// 盖盖子 + stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModGripperZM,// + tubePreProcesPosMgr.getZMotorShakeTubePos() + tubePreProcesPosMgr.getGripperRedundancySpacingForTubeCap(), + actionOvertime); - //移动Y轴到方式管的位置 - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperYSV, pp.getGripperTakeTubeYPos(), timep.getActionOvertime()); - //移动Z轴到取试管位置 - stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModGripperZM, pp.getGripperTakeHTubeZPos() - 20, timep.getActionOvertime()); - //打开夹爪 - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, pp.getGripperOpenPos(), timep.getActionOvertime()); + //释放试管 + clampingMReleaseTube(); //Z轴上移动到零位 - stepMotorControler.stepMotorEasyMoveToZeroPointQuickBlock(StepMotorMId.ShakeModGripperZM, timep.getActionOvertime()); + zMotorMoveToZeroQuick(); + //Y轴移动到零位 + YSVMoveToTakeTubePos(); + //移动到放试管的位置 + stepMotorControler.stepMotorEasyMoveToBlock(StepMotorMId.ShakeModGripperZM,// + tubePreProcesPosMgr.getZMotorTakeHTubePos() , + actionOvertime); + //打开夹爪 + gripperSVOpen(); //设备快速归零 modGroupMoveToZeroQuick(); } - - /** - * 气溶胶风扇控制 - */ - @ExtApiFn(name = "气溶胶风扇控制", group = "其他", order = ORDER.setAeroslFanPower) - public void setAeroslFanPower(Boolean enable) throws Exception { - if (enable) { - canBus.fanControlerSetSpeed(MId.WbTubeFanMod, 99); - } else { - canBus.fanControlerSetSpeed(MId.WbTubeFanMod, 0); - } - } - - // /** - // * 移动试管到试管预处理的位置 - // * @param tubeIndex 试管索引 - // */ - // public void moveTubeToPreProcessPos(Integer tubeIndex) throws AppException { - // moveTubeRackTo(stp.getTPreProcessXPos() + tubeIndex * tubeHolderParamMgr.getTubeSpacing(), TargetPosMeasureDirection.POSITIVE, false); - // } - - // 677 - public void gripperSVOpen() throws AppException { - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, tubePreProcesPosMgr.getGripperServoOpenPos(), actionOvertime); - } - - public void gripperSVCClose() throws AppException { - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, tubePreProcesPosMgr.getGripperServoClosePos(), actionOvertime); - } - - public void gripperSVClampTube() throws AppException { - miniServoControler.miniServoMoveToBlock(MiniServoMId.ShakeModGripperSV, tubePreProcesPosMgr.getGripperServoClosePos(), actionOvertime); - } } diff --git a/src/main/java/a8k/service/app/devicedriver/pos/TubeFeedingModulePosMgr.java b/src/main/java/a8k/service/app/devicedriver/pos/TubeFeedingModulePosMgr.java index 72fed83..9d29c42 100644 --- a/src/main/java/a8k/service/app/devicedriver/pos/TubeFeedingModulePosMgr.java +++ b/src/main/java/a8k/service/app/devicedriver/pos/TubeFeedingModulePosMgr.java @@ -14,19 +14,18 @@ import org.springframework.stereotype.Component; public class TubeFeedingModulePosMgr { static final Logger logger = LoggerFactory.getLogger(TubeFeedingModulePosMgr.class); - public final Integer ScanerClampingSVReleasePos = 100; - public final Integer ScanerClampingSVClampingPos = 1000; +// public final Integer ScanerClampingSVReleasePos = 100; +// public final Integer ScanerClampingSVClampingPos = 1000; public enum POS { TubeHolderEnterXPos, // 入料位置 TubeHolderExitXPos, // 出料位置 TubeHolderScanXPos, // 试管架扫描位置 - Tube0ScanXPos, // 0号试管扫描位置 - Tube0AltitJudgXPos, // 0试管高度判断位置 - Tube0ExistJudgXPos, // 0试管存在判断位置 + Tube0ScanXPos, // 0号试管扫描位置 + Tube0AltitJudgXPos, // 0试管高度判断位置 + Tube0ExistJudgXPos, // 0试管存在判断位置 Tube0PreProcessXPos, // 0试管预处理位置 - TubeScanServoTorque,// 试管扫描伺服力矩 - + TubeScanServoTorque, // 试管扫描伺服力矩 } @Resource diff --git a/src/main/java/a8k/service/app/devicedriver/pos/TubePreProcesPosMgr.java b/src/main/java/a8k/service/app/devicedriver/pos/TubePreProcesPosMgr.java index 36ecdfd..a0618b7 100644 --- a/src/main/java/a8k/service/app/devicedriver/pos/TubePreProcesPosMgr.java +++ b/src/main/java/a8k/service/app/devicedriver/pos/TubePreProcesPosMgr.java @@ -18,15 +18,13 @@ public class TubePreProcesPosMgr { GripperServoTakeCapPos("抓手取试管位置"),// YServoTakeTubePos("取试管位置"),// YServoShakePos("摇匀位置"),// - YServoZeroYPos("待机位"),// ZMotorTakeHTubePos("取高试管位置"),// - ZMotorTakeSTubePos("取低试管位置"),// - ZMotorJudgeHTubeCapPos("高试管帽有无判断位"),// - ZMotorJudgeSTubeCapPos("低试管帽有无判断位"),// + // ZMotorTakeSTubePos("取低试管位置"),// ZMotorShakeTubePos("摇匀放置位置"),// - ZMotorTakeCapPos("取试管帽位"),// ShakeClampMotorClampPos("试管夹紧位"),// ShakeClampMotorReleasePos("摇匀臂"),// + + GripperRedundancySpacingForTubeCap("夹爪试管帽冗余间距"),// ; public final String chName; @@ -51,139 +49,66 @@ public class TubePreProcesPosMgr { logger.info("init param"); posReader.setVersion(nowParaVersion); - // 677,450,310,355 - // 1800,1573,1433,1388 - posReader.updatePos(POS.GripperServoOpenPos, 1573); - posReader.updatePos(POS.GripperServoClosePos, 1433); - posReader.updatePos(POS.GripperServoTakeCapPos, 1388); - posReader.updatePos(POS.YServoTakeTubePos, 3080); + posReader.updatePos(POS.GripperServoOpenPos, 1600); + posReader.updatePos(POS.GripperServoClosePos, 1460); + posReader.updatePos(POS.GripperServoTakeCapPos, 1515); + + posReader.updatePos(POS.YServoTakeTubePos, 3000); posReader.updatePos(POS.YServoShakePos, 2130); - posReader.updatePos(POS.YServoZeroYPos, 300); + posReader.updatePos(POS.ZMotorTakeHTubePos, 739); - posReader.updatePos(POS.ZMotorTakeSTubePos, 983); - posReader.updatePos(POS.ZMotorJudgeHTubeCapPos, 591); - posReader.updatePos(POS.ZMotorJudgeSTubeCapPos, 867); posReader.updatePos(POS.ZMotorShakeTubePos, 835); - posReader.updatePos(POS.ZMotorTakeCapPos, 835); + posReader.updatePos(POS.ShakeClampMotorClampPos, 10); posReader.updatePos(POS.ShakeClampMotorReleasePos, 90); - } - } - - - public Integer getParam(POS pos) { - return posReader.getPos(pos, Integer.class); - } - - public Integer getGripperServoOpenPos() { - return getParam(POS.GripperServoOpenPos); - } - - public void setGripperServoOpenPos(Integer value) { - posReader.updatePos(POS.GripperServoOpenPos, value); - } - - public Integer getGripperServoClosePos() { - return getParam(POS.GripperServoClosePos); - } - public void setGripperServoClosePos(Integer value) { - posReader.updatePos(POS.GripperServoClosePos, value); + posReader.updatePos(POS.GripperRedundancySpacingForTubeCap, 20); + } } - public Integer getGripperServoTakeCapPos() { - return getParam(POS.GripperServoTakeCapPos); - } - public void setGripperServoTakeCapPos(Integer value) { - posReader.updatePos(POS.GripperServoTakeCapPos, value); - } + public Integer getParam(POS pos) {return posReader.getPos(pos, Integer.class);} - public Integer getYServoTakeTubePos() { - return getParam(POS.YServoTakeTubePos); - } + public Integer getGripperServoOpenPos() {return getParam(POS.GripperServoOpenPos);} - public void setYServoTakeTubePos(Integer value) { - posReader.updatePos(POS.YServoTakeTubePos, value); - } + public Integer getGripperServoClosePos() {return getParam(POS.GripperServoClosePos);} - public Integer getYServoShakePos() { - return getParam(POS.YServoShakePos); - } + public Integer getGripperServoTakeCapPos() {return getParam(POS.GripperServoTakeCapPos);} - public void setYServoShakePos(Integer value) { - posReader.updatePos(POS.YServoShakePos, value); - } + public Integer getYServoTakeTubePos() {return getParam(POS.YServoTakeTubePos);} - public Integer getYServoZeroYPos() { - return getParam(POS.YServoZeroYPos); - } + public Integer getYServoShakePos() {return getParam(POS.YServoShakePos);} - public void setYServoZeroYPos(Integer value) { - posReader.updatePos(POS.YServoZeroYPos, value); - } + public Integer getZMotorTakeHTubePos() {return getParam(POS.ZMotorTakeHTubePos);} - public Integer getZMotorTakeHTubePos() { - return getParam(POS.ZMotorTakeHTubePos); - } + // public Integer getZMotorTakeSTubePos() {return getParam(POS.ZMotorTakeSTubePos);} - public void setZMotorTakeHTubePos(Integer value) { - posReader.updatePos(POS.ZMotorTakeHTubePos, value); - } + public Integer getZMotorShakeTubePos() {return getParam(POS.ZMotorShakeTubePos);} - public Integer getZMotorTakeSTubePos() { - return getParam(POS.ZMotorTakeSTubePos); - } + public Integer getShakeClampMotorClampPos() {return getParam(POS.ShakeClampMotorClampPos);} - public void setZMotorTakeSTubePos(Integer value) { - posReader.updatePos(POS.ZMotorTakeSTubePos, value); - } + public Integer getShakeClampMotorReleasePos() {return getParam(POS.ShakeClampMotorReleasePos);} - public Integer getZMotorJudgeHTubeCapPos() { - return getParam(POS.ZMotorJudgeHTubeCapPos); - } + public Integer getGripperRedundancySpacingForTubeCap() {return getParam(POS.GripperRedundancySpacingForTubeCap);} - public void setZMotorJudgeHTubeCapPos(Integer value) { - posReader.updatePos(POS.ZMotorJudgeHTubeCapPos, value); - } - public Integer getZMotorJudgeSTubeCapPos() { - return getParam(POS.ZMotorJudgeSTubeCapPos); - } + public void setGripperServoOpenPos(Integer value) {posReader.updatePos(POS.GripperServoOpenPos, value);} - public void setZMotorJudgeSTubeCapPos(Integer value) { - posReader.updatePos(POS.ZMotorJudgeSTubeCapPos, value); - } + public void setGripperServoClosePos(Integer value) {posReader.updatePos(POS.GripperServoClosePos, value);} - public Integer getZMotorShakeTubePos() { - return getParam(POS.ZMotorShakeTubePos); - } + public void setGripperServoTakeCapPos(Integer value) {posReader.updatePos(POS.GripperServoTakeCapPos, value);} - public void setZMotorShakeTubePos(Integer value) { - posReader.updatePos(POS.ZMotorShakeTubePos, value); - } + public void setYServoTakeTubePos(Integer value) {posReader.updatePos(POS.YServoTakeTubePos, value);} - public Integer getZMotorTakeCapPos() { - return getParam(POS.ZMotorTakeCapPos); - } + public void setYServoShakePos(Integer value) {posReader.updatePos(POS.YServoShakePos, value);} - public void setZMotorTakeCapPos(Integer value) { - posReader.updatePos(POS.ZMotorTakeCapPos, value); - } + public void setZMotorTakeHTubePos(Integer value) {posReader.updatePos(POS.ZMotorTakeHTubePos, value);} - public Integer getShakeClampMotorClampPos() { - return getParam(POS.ShakeClampMotorClampPos); - } + public void setZMotorShakeTubePos(Integer value) {posReader.updatePos(POS.ZMotorShakeTubePos, value);} - public void setShakeClampMotorClampPos(Integer value) { - posReader.updatePos(POS.ShakeClampMotorClampPos, value); - } + public void setShakeClampMotorClampPos(Integer value) {posReader.updatePos(POS.ShakeClampMotorClampPos, value);} - public Integer getShakeClampMotorReleasePos() { - return getParam(POS.ShakeClampMotorReleasePos); - } + public void setShakeClampMotorReleasePos(Integer value) {posReader.updatePos(POS.ShakeClampMotorReleasePos, value);} - public void setShakeClampMotorReleasePos(Integer value) { - posReader.updatePos(POS.ShakeClampMotorReleasePos, value); - } + public void setGripperRedundancySpacingForTubeCap(Integer value) {posReader.updatePos(POS.GripperRedundancySpacingForTubeCap, value);} } diff --git a/src/main/java/a8k/service/db/LowerDeviceParameterDBService.java b/src/main/java/a8k/service/db/LowerDeviceParameterDBService.java index e32a3fa..f4376be 100644 --- a/src/main/java/a8k/service/db/LowerDeviceParameterDBService.java +++ b/src/main/java/a8k/service/db/LowerDeviceParameterDBService.java @@ -53,6 +53,7 @@ public class LowerDeviceParameterDBService { } public void updateParam(String service, String key, Object pos) { + logger.info("updateParam: service={}, key={}, pos={}", service, key, pos); try { ObjectMapper objectMapper = new ObjectMapper(); List list = jdbcTemplate.query("select * from " + tableName + " where service = ? and key = ?;", this::rowMapper, service, key);