project_boditech_vidas_a8000_v3
/
a8k_app
7
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity
Browse Source

update

tags/v0
zhaohe 10 months ago
parent
6b93a610e5
commit
9f2ce9aff3
12 changed files with 824 additions and 743 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. BIN
      app.db
  2. 49
      src/main/java/a8k/constant/MiniServoConstant.java
  3. 39
      src/main/java/a8k/service/app/devicedriver/basectrl/MiniServoControler.java
  4. 5
      src/main/java/a8k/service/app/devicedriver/basectrl/TubeTransportControler.java
  5. 4
      src/main/java/a8k/service/app/devicedriver/calibration/TubeFeedingModulePosCalibration.java
  6. 197
      src/main/java/a8k/service/app/devicedriver/calibration/TubePreProcesPosCalibration.java
  7. 754
      src/main/java/a8k/service/app/devicedriver/commonctrl/HardwareCommonCtrl.java
  8. 10
      src/main/java/a8k/service/app/devicedriver/ctrl/DeviceInitCtrlService.java
  9. 352
      src/main/java/a8k/service/app/devicedriver/ctrl/TubePreProcesControler.java
  10. 13
      src/main/java/a8k/service/app/devicedriver/pos/TubeFeedingModulePosMgr.java
  11. 143
      src/main/java/a8k/service/app/devicedriver/pos/TubePreProcesPosMgr.java
  12. 1
      src/main/java/a8k/service/db/LowerDeviceParameterDBService.java

BIN
app.db
View File

49
src/main/java/a8k/constant/MiniServoConstant.java
View File

@ -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;
}
}

39
src/main/java/a8k/service/app/devicedriver/basectrl/MiniServoControler.java
View File

@ -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 {

5
src/main/java/a8k/service/app/devicedriver/basectrl/TubeTransportControler.java
View File

@ -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);
}

4
src/main/java/a8k/service/app/devicedriver/calibration/TubeFeedingModulePosCalibration.java
View File

@ -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);
}

197
src/main/java/a8k/service/app/devicedriver/calibration/TubePreProcesPosCalibration.java
View File

@ -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();
}
}

754
src/main/java/a8k/service/app/devicedriver/commonctrl/HardwareCommonCtrl.java
View File

@ -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<Object> 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<Object> 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;
// }
//
//}

10
src/main/java/a8k/service/app/devicedriver/ctrl/DeviceInitCtrlService.java
View File

@ -36,9 +36,9 @@ public class DeviceInitCtrlService {
@Resource
AppDebugHelperService appDebugHelper;
@Resource
MiniServoControler miniServoControler;
MiniServoControler miniServoControler;
@Resource
StepMotorControler stepMotorControler;
StepMotorControler stepMotorControler;
Integer actionOvertime = 10000;
List<Checkpoint> 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));

352
src/main/java/a8k/service/app/devicedriver/ctrl/TubePreProcesControler.java
View File

@ -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);
}
}

13
src/main/java/a8k/service/app/devicedriver/pos/TubeFeedingModulePosMgr.java
View File

@ -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

143
src/main/java/a8k/service/app/devicedriver/pos/TubePreProcesPosMgr.java
View File

@ -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);}
}

1
src/main/java/a8k/service/db/LowerDeviceParameterDBService.java
View File

@ -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<Parameter> list = jdbcTemplate.query("select * from " + tableName + " where service = ? and key = ?;", this::rowMapper, service, key);

Write Preview
Loading…
Cancel
Save