diff --git a/src/main/java/a8k/app/constant/ActionOvertimeConstant.java b/src/main/java/a8k/app/constant/ActionOvertimeConstant.java index b1634d4..ca8a1fa 100644 --- a/src/main/java/a8k/app/constant/ActionOvertimeConstant.java +++ b/src/main/java/a8k/app/constant/ActionOvertimeConstant.java @@ -33,7 +33,7 @@ public class ActionOvertimeConstant { pushNewConfig(StepMotorMId.FeedingModXM, CmdId.step_motor_easy_move_to_zero, 15 * 1000); pushNewConfig(StepMotorMId.FeedingModXM, CmdId.step_motor_easy_move_to_end_point, 15 * 1000); - pushNewConfig(MId.PipetteMod, CmdId.pipette_pump_distribu, 30 * 1000); + pushNewConfig(MId.PipetteMod, CmdId.pipette_pump_distribu_all, 30 * 1000); pushNewConfig(MId.PipetteMod, CmdId.pipette_pump_aspirate, 30 * 1000); pushNewConfig(MId.PipetteMod, CmdId.pipette_test_lld, 30 * 1000); pushNewConfig(MId.PipetteMod, CmdId.pipette_test_pump_move_to_x100nl, 30 * 1000); diff --git a/src/main/java/a8k/app/hardware/driver/PipetteCtrlDriverV2.java b/src/main/java/a8k/app/hardware/driver/PipetteCtrlDriverV2.java index 5eb341b..28ef66a 100644 --- a/src/main/java/a8k/app/hardware/driver/PipetteCtrlDriverV2.java +++ b/src/main/java/a8k/app/hardware/driver/PipetteCtrlDriverV2.java @@ -4,11 +4,14 @@ import a8k.app.constant.ActionOvertimeConstant; import a8k.app.hardware.channel.A8kCanBusService; import a8k.app.hardware.type.*; import a8k.app.hardware.type.pipette_module.AspirationParamId; +import a8k.app.hardware.type.pipette_module.DistribuAllParamId; import a8k.app.hardware.type.pipette_module.PipetteConfig; import a8k.app.hardware.type.pipette_module.PipetteStateIndex; import a8k.app.hardware.type.pipette_module.cfgbean.*; import a8k.app.hardware.type.pipette_module.cpyidx.*; import a8k.app.hardware.type.pipette_module.cfg.*; +import a8k.app.hardware.type.pipette_module.param.AspirationParam; +import a8k.app.hardware.type.pipette_module.param.DistribuAllParam; import a8k.app.type.exception.AppException; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; @@ -320,15 +323,15 @@ public class PipetteCtrlDriverV2 { callcmd(MId.PipetteMod, CmdId.pipette_pump_aspirate_set_param, param.toInteger(), val); } + public void pipettePumpAspirateSetParam(AspirationParam param) throws AppException { + param.serialization(this::pipettePumpAspirateSetParam); + } + public void pipettePumpAspirateBlock() throws AppException { callcmd(MId.PipetteMod, CmdId.pipette_pump_aspirate); waitForMod(CmdId.pipette_pump_aspirate); } - public void pipettePumpDistributeBlock() throws AppException { - callcmd(MId.PipetteMod, CmdId.pipette_pump_distribu); - waitForMod(CmdId.pipette_pump_distribu); - } public void pipetteTestPumpMoveToX100nl(Integer x100nl, Integer vcfgIndex) throws AppException { callcmd(MId.PipetteMod, CmdId.pipette_test_pump_move_to_x100nl, x100nl, vcfgIndex); @@ -340,6 +343,60 @@ public class PipetteCtrlDriverV2 { waitForMod(CmdId.pipette_test_lld); } + public void pipetteTestMoveToContainerBottom(Integer containerPos, ContainerCpyId containerCpyId) throws AppException { + callcmd(MId.PipetteMod, CmdId.pipette_test_move_to_container_bottom, containerPos, containerCpyId.toInteger()); + waitForMod(CmdId.pipette_test_move_to_container_bottom); + } + + public void pipetteTestMoveToContainerBottomSectionBegin(Integer containerPos, ContainerCpyId containerCpyId) throws AppException { + callcmd(MId.PipetteMod, CmdId.pipette_test_move_to_container_bottom_section_begin, containerPos, containerCpyId.toInteger()); + waitForMod(CmdId.pipette_test_move_to_container_bottom_section_begin); + } + + public void pipetteTestMoveToImmersionPos(Integer containerPos, ContainerCpyId containerCpyId) throws AppException { + callcmd(MId.PipetteMod, CmdId.pipette_test_move_to_immersion_pos, containerPos, containerCpyId.toInteger()); + waitForMod(CmdId.pipette_test_move_to_immersion_pos); + } + + public void pipetteTestMoveToLeavingHeightPos(Integer containerPos, ContainerCpyId containerCpyId) throws AppException { + callcmd(MId.PipetteMod, CmdId.pipette_test_move_to_leaving_height_pos, containerPos, containerCpyId.toInteger()); + waitForMod(CmdId.pipette_test_move_to_leaving_height_pos); + } + + public void pipetteTestMoveToJetPos(Integer containerPos, ContainerCpyId containerCpyId) throws AppException { + callcmd(MId.PipetteMod, CmdId.pipette_test_move_to_jet_pos, containerPos, containerCpyId.toInteger()); + waitForMod(CmdId.pipette_test_move_to_jet_pos); + } + + public void pipetteTestMoveToLldStartSearchPos(Integer containerPos, ContainerCpyId containerCpyId) throws AppException { + callcmd(MId.PipetteMod, CmdId.pipette_test_move_to_lld_start_search_pos, containerPos, containerCpyId.toInteger()); + waitForMod(CmdId.pipette_test_move_to_lld_start_search_pos); + } + + public void pipetteTestMoveToFixWaterLevelPos(Integer containerPos, ContainerCpyId containerCpyId) throws AppException { + callcmd(MId.PipetteMod, CmdId.pipette_test_move_to_fix_water_level_pos, containerPos, containerCpyId.toInteger()); + waitForMod(CmdId.pipette_test_move_to_fix_water_level_pos); + } + + public void pipetteTestMoveToPiercePos(Integer containerPos, ContainerCpyId containerCpyId) throws AppException { + callcmd(MId.PipetteMod, CmdId.pipette_test_move_to_pierce_pos, containerPos, containerCpyId.toInteger()); + waitForMod(CmdId.pipette_test_move_to_pierce_pos); + } + + + public void pipettePumpDistributeAllSetParam(DistribuAllParamId param, Integer val) throws AppException { + callcmd(MId.PipetteMod, CmdId.pipette_pump_distribu_all_set_param, param.toInteger(), val); + } + + public void pipettePumpDistributeAllSetParam(DistribuAllParam param) throws AppException { + param.serialization(this::pipettePumpDistributeAllSetParam); + } + + public void pipettePumpDistributeAllBlock() throws AppException { + callcmd(MId.PipetteMod, CmdId.pipette_pump_distribu_all); + waitForMod(CmdId.pipette_pump_distribu_all); + } + public Integer readState(PipetteStateIndex index) throws AppException { return callcmd(MId.PipetteMod, CmdId.pipette_read_state, index.toInteger()).getContentI32(0); } @@ -368,7 +425,6 @@ public class PipetteCtrlDriverV2 { } - // // Config // diff --git a/src/main/java/a8k/app/hardware/type/CmdId.java b/src/main/java/a8k/app/hardware/type/CmdId.java index afe3030..e33ad56 100644 --- a/src/main/java/a8k/app/hardware/type/CmdId.java +++ b/src/main/java/a8k/app/hardware/type/CmdId.java @@ -191,7 +191,6 @@ public enum CmdId { pipette_pump_pierce_through(0x7583, "pipette_pump_aspirate_set_param"), pipette_pump_aspirate_set_param(0x7584, "pipette_pump_aspirate_set_param"), pipette_pump_aspirate(0x7585, "pipette_pump_aspirate"), - pipette_pump_distribu(0x7586, "pipette_pump_distribu"), pipette_get_sensor_sample_data(0x7587, "pipette_get_sensor_sample_data"), pipette_get_sensor_sample_data_num(0x7588, "pipette_get_sensor_sample_data_num"), pipette_read_state(0x7589, "pipette_read_state"), @@ -199,9 +198,20 @@ public enum CmdId { pipette_read_tip_state(0x758B, "pipette_read_tip_state"), pipette_read_pressure(0x758C, "pipette_read_pressure"), pipette_read_capacitance(0x758D, "pipette_read_capacitance"), + pipette_pump_distribu_all_set_param(0x758E, "pipette_pump_distribu_all_set_param"), // {paramid,val}, ack:{} + pipette_pump_distribu_all(0x758F, "pipette_pump_distribu_all"), // {}, ack:{} + pipette_test_pump_move_to_x100nl(0x7600, "pipette_test_pump_move_to_x100nl"), // int32_t x100nl, int32_t vcfgindex pipette_test_lld(0x7601, "pipette_test_lld"), // int32_t container_pos, int32_t container_cpyid, int32_t liquid_cpyid + pipette_test_move_to_container_bottom(0x7602, "pipette_test_move_to_container_bottom"), // int32_t container_pos, int32_t container_cpyid, + pipette_test_move_to_container_bottom_section_begin(0x7603, "pipette_test_move_to_container_bottom_section_begin"), // int32_t container_pos, int32_t container_cpyid, + pipette_test_move_to_immersion_pos(0x7604, "pipette_test_move_to_immersion_pos"), // int32_t container_pos, int32_t container_cpyid, + pipette_test_move_to_leaving_height_pos(0x7605, "pipette_test_move_to_leaving_height_pos"), // int32_t container_pos, int32_t container_cpyid, + pipette_test_move_to_jet_pos(0x7606, "pipette_test_move_to_jet_pos"), // int32_t container_pos, int32_t container_cpyid, + pipette_test_move_to_lld_start_search_pos(0x7607, "pipette_test_move_to_lld_start_search_pos"), // int32_t container_pos, int32_t container_cpyid, + pipette_test_move_to_fix_water_level_pos(0x7608, "pipette_test_move_to_fix_water_level_pos"), // int32_t container_pos, int32_t container_cpyid, + pipette_test_move_to_pierce_pos(0x7609, "pipette_test_move_to_pierce_pos"), // int32_t container_pos, int32_t container_cpyid, ; public final static int ATTACH_IS_BYTES = 1; diff --git a/src/main/java/a8k/app/hardware/type/pipette_module/AspirationParamId.java b/src/main/java/a8k/app/hardware/type/pipette_module/AspirationParamId.java index 170211b..3918c41 100644 --- a/src/main/java/a8k/app/hardware/type/pipette_module/AspirationParamId.java +++ b/src/main/java/a8k/app/hardware/type/pipette_module/AspirationParamId.java @@ -8,32 +8,32 @@ public enum AspirationParamId { // // 容器 // - container_pos, - container_info_index, + containerPos, + containerInfoIndex, // // 液体类型 // - liquid_cfg_index, + liquidCfgIndex, // // 吸取模式 // - aspiration_mode, + aspirationMode, // // lld配置 // - lld_enable, - lld_type, - lld_enable_protect, + lldEnable, + lldType, + lldEnableProtect, // // llf配置 // - mix_llf_enable, - llf_enable, + mixLlfEnable, + llfEnable, // // 混匀配置 // - mix_volume, - mix_times, + mixVolume, + mixTimes, ; public Integer toInteger() { diff --git a/src/main/java/a8k/app/hardware/type/pipette_module/DistribuAllParamId.java b/src/main/java/a8k/app/hardware/type/pipette_module/DistribuAllParamId.java new file mode 100644 index 0000000..5e43a8a --- /dev/null +++ b/src/main/java/a8k/app/hardware/type/pipette_module/DistribuAllParamId.java @@ -0,0 +1,35 @@ +package a8k.app.hardware.type.pipette_module; + +public enum DistribuAllParamId { + // + // 容器位置 + // + containerPos, // 容器位置 + + // + // 目标容器信息 + // + destContainerCpyid, // 目标容器配置索引 + destContainerIsEmpty, // 目标容器是否为空 + destLiquidCfgIndex, // 目标容器中的液体类型 + + // + // 分配方式 + // + distribuType, // 分配类型 0:液面上分配,1:液面下分配 + + // + // 混匀配置 + // + mixVolume, // 混匀体积 + mixTimes, // 混匀次数 + // + // 其他配置 + // + zmAutoMoveToZero, // zm自动归零 + ; + + public Integer toInteger() { + return ordinal(); + } +} diff --git a/src/main/java/a8k/app/hardware/type/pipette_module/param/AspirationParam.java b/src/main/java/a8k/app/hardware/type/pipette_module/param/AspirationParam.java new file mode 100644 index 0000000..2c4fd97 --- /dev/null +++ b/src/main/java/a8k/app/hardware/type/pipette_module/param/AspirationParam.java @@ -0,0 +1,87 @@ +package a8k.app.hardware.type.pipette_module.param; + +import a8k.app.hardware.type.pipette_module.AspirationParamId; +import a8k.app.type.exception.AppException; + +public class AspirationParam { + // + // 吸取体积 + // + public Integer volume; + // + // 容器 + // + public Integer containerPos; + public Integer containerInfoIndex; + // + // 液体类型 + // + public Integer liquidCfgIndex; + // + // 吸取模式 + // + public Integer aspirationMode; + // + // lld配置 + // + public Integer lldEnable; + public Integer lldType; + public Integer lldEnableProtect; + // + // llf配置 + // + public Integer mixLlfEnable; + public Integer llfEnable; + // + // 混匀配置 + // + public Integer mixVolume; + public Integer mixTimes; + + @FunctionalInterface + public interface AssignObjectItemFn { + Integer assignVal(AspirationParamId index) throws AppException; + } + + @FunctionalInterface + public interface SerializationObjectItemFn { + void serializeObject(AspirationParamId index, Integer itermVal) throws AppException; + } + + public static AspirationParam build(AssignObjectItemFn assignFn) throws AppException { + AspirationParam info = new AspirationParam(); + info.assignObject(assignFn); + return info; + } + + public void assignObject(AssignObjectItemFn assignFn) throws AppException { + for (AspirationParamId idx : AspirationParamId.values()) { + try { + AspirationParam.class.getDeclaredField(idx.name()).set(this, assignFn.assignVal(idx)); + } catch (IllegalAccessException | NoSuchFieldException e) { + throw new RuntimeException(e); + } + } + } + + public void serialization(SerializationObjectItemFn fn) throws AppException { + for (AspirationParamId idx : AspirationParamId.values()) { + try { + Integer val = (Integer) AspirationParam.class.getDeclaredField(idx.name()).get(this); + fn.serializeObject(idx, val); + } catch (NoSuchFieldException | IllegalAccessException e) { + throw new RuntimeException(e); + } + } + } + + public static void main(String[] args) throws AppException { + AspirationParam info = new AspirationParam(); + info.assignObject(Enum::ordinal); + + info.serialization((index, val) -> { + System.out.println("Index: " + index + ", Value: " + val); + }); + } + +} diff --git a/src/main/java/a8k/app/hardware/type/pipette_module/param/DistribuAllParam.java b/src/main/java/a8k/app/hardware/type/pipette_module/param/DistribuAllParam.java new file mode 100644 index 0000000..6baa03c --- /dev/null +++ b/src/main/java/a8k/app/hardware/type/pipette_module/param/DistribuAllParam.java @@ -0,0 +1,56 @@ +package a8k.app.hardware.type.pipette_module.param; + +import a8k.app.hardware.type.pipette_module.DistribuAllParamId; +import a8k.app.type.exception.AppException; + +public class DistribuAllParam { + // + // 容器位置 + // + public Integer containerPos = 0; // 容器位置 + + // + // 目标容器信息 + // + public Integer destContainerCpyid = 0; // 目标容器配置索引 + public Integer destContainerIsEmpty = 0; // 目标容器是否为空 + public Integer destLiquidCfgIndex = 0; // 目标容器中的液体类型 + + // + // 分配方式 + // + public Integer distribuType = 0; // 分配类型 0:液面上分配,1:液面下分配 + + // + // 混匀配置 + // + public Integer mixVolume = 0; // 混匀体积 + public Integer mixTimes = 0; // 混匀次数 + // + // 其他配置 + // + public Integer zmAutoMoveToZero = 0; // zm自动归零 + + @FunctionalInterface + public interface SerializationObjectItemFn { + void serializeObject(DistribuAllParamId index, Integer itermVal) throws AppException; + } + + + public void serialization(SerializationObjectItemFn fn) throws AppException { + for (DistribuAllParamId idx : DistribuAllParamId.values()) { + try { + Integer val = (Integer) DistribuAllParam.class.getDeclaredField(idx.name()).get(this); + fn.serializeObject(idx, val); + } catch (NoSuchFieldException | IllegalAccessException e) { + throw new RuntimeException(e); + } + } + } + + public static void main(String[] args) throws AppException { + DistribuAllParam info = new DistribuAllParam(); + info.serialization((index, val) -> System.out.println("Index: " + index + ", Value: " + val)); + } + +} diff --git a/src/main/java/a8k/extui/page/driver/pipette_module/PipetteGunOperationCtrlPage.java b/src/main/java/a8k/extui/page/driver/pipette_module/PipetteGunOperationCtrlPage.java index 184d015..b843898 100644 --- a/src/main/java/a8k/extui/page/driver/pipette_module/PipetteGunOperationCtrlPage.java +++ b/src/main/java/a8k/extui/page/driver/pipette_module/PipetteGunOperationCtrlPage.java @@ -7,6 +7,8 @@ import a8k.app.hardware.type.pipette_module.cfg.LiquidInfoIndex; import a8k.app.hardware.type.pipette_module.cfg.PlatformInfoIndex; import a8k.app.hardware.type.pipette_module.cpyidx.ContainerCpyId; import a8k.app.hardware.type.pipette_module.cpyidx.LiquidConfigCpyIdx; +import a8k.app.hardware.type.pipette_module.param.AspirationParam; +import a8k.app.hardware.type.pipette_module.param.DistribuAllParam; import a8k.app.type.exception.AppException; import a8k.extui.mgr.ExtApiPageMgr; import jakarta.annotation.PostConstruct; @@ -25,38 +27,110 @@ public class PipetteGunOperationCtrlPage { Integer platInfoCpyId = 0; - Integer volume = 10; - Integer containerPos = 100; - ContainerCpyId containerInfoIndex = ContainerCpyId.Default; - LiquidConfigCpyIdx liquidCfgIndex = LiquidConfigCpyIdx.Default; - Integer aspirationMode = 0;//only support 0 - Integer lldEnable = 0; - Integer lldType = 0;//only support 0 - Integer lldEnableProtect = 0; - Integer mixLlfEnable = 0; - Integer llfEnable = 0; - Integer mixVolume = 0; - Integer mixTimes = 0; + AspirationParam aspirateParam = new AspirationParam(); + DistribuAllParam distributeParam = new DistribuAllParam(); + + // + void setAspirationParamVolume(Integer volume) { + aspirateParam.volume = volume; + } + + void setAspirationParamContainerPos(Integer containerPos) { + aspirateParam.containerPos = containerPos; + } + + void setAspirationParamContainerInfoIndex(Integer containerInfoIndex) { + aspirateParam.containerInfoIndex = containerInfoIndex; + } + + void setAspirationParamLiquidCfgIndex(Integer liquidCfgIndex) { + aspirateParam.liquidCfgIndex = liquidCfgIndex; + } + + void setAspirationParamAspirationMode(Integer aspirationMode) { + aspirateParam.aspirationMode = aspirationMode; + } + + void setAspirationParamLldEnable(Integer lldEnable) { + aspirateParam.lldEnable = lldEnable; + } + + void setAspirationParamLldType(Integer lldType) { + aspirateParam.lldType = lldType; + } + + void setAspirationParamLldEnableProtect(Integer lldEnableProtect) { + aspirateParam.lldEnableProtect = lldEnableProtect; + } + + void setAspirationParamMixLlfEnable(Integer mixLlfEnable) { + aspirateParam.mixLlfEnable = mixLlfEnable; + } + + void setAspirationParamLlfEnable(Integer llfEnable) { + aspirateParam.llfEnable = llfEnable; + } + + void setAspirationParamMixVolume(Integer mixVolume) { + aspirateParam.mixVolume = mixVolume; + } + + void setAspirationParamMixTimes(Integer mixTimes) { + aspirateParam.mixTimes = mixTimes; + } + + // containerPos + //destContainerCpyid + //destContainerIsEmpty + //destLiquidCfgIndex + //distribuType + //mixVolume + //mixTimes + //zmAutoMoveToZero + public void setDistributeParam_containerPos(Integer containerPos) { + distributeParam.containerPos = containerPos; + } + + public void setDistributeParam_destContainerCpyid(Integer destContainerCpyid) { + distributeParam.destContainerCpyid = destContainerCpyid; + } + + public void setDistributeParam_destContainerIsEmpty(Integer destContainerIsEmpty) { + distributeParam.destContainerIsEmpty = destContainerIsEmpty; + } + + public void setDistributeParam_destLiquidCfgIndex(Integer destLiquidCfgIndex) { + distributeParam.destLiquidCfgIndex = destLiquidCfgIndex; + } + + public void setDistributeParam_distribuType(Integer distribuType) { + distributeParam.distribuType = distribuType; + } + + public void setDistributeParam_mixVolume(Integer mixVolume) { + distributeParam.mixVolume = mixVolume; + } + + public void setDistributeParam_mixTimes(Integer mixTimes) { + distributeParam.mixTimes = mixTimes; + } + + public void setDistributeParam_zmAutoMoveToZero(Integer zmAutoMoveToZero) { + distributeParam.zmAutoMoveToZero = zmAutoMoveToZero; + } - // pipetteCtrlDriverV2.pipettePumpAspirateSetParam(AspirationParamId.volume, volume); public void execAspirate() throws AppException { - pipetteCtrlDriverV2.pipettePumpAspirateSetParam(AspirationParamId.volume, volume); - pipetteCtrlDriverV2.pipettePumpAspirateSetParam(AspirationParamId.container_pos, containerPos); - pipetteCtrlDriverV2.pipettePumpAspirateSetParam(AspirationParamId.container_info_index, containerInfoIndex.toInteger()); - pipetteCtrlDriverV2.pipettePumpAspirateSetParam(AspirationParamId.liquid_cfg_index, liquidCfgIndex.toInteger()); - pipetteCtrlDriverV2.pipettePumpAspirateSetParam(AspirationParamId.aspiration_mode, aspirationMode); - pipetteCtrlDriverV2.pipettePumpAspirateSetParam(AspirationParamId.lld_enable, lldEnable); - pipetteCtrlDriverV2.pipettePumpAspirateSetParam(AspirationParamId.lld_type, lldType); - pipetteCtrlDriverV2.pipettePumpAspirateSetParam(AspirationParamId.lld_enable_protect, lldEnableProtect); - pipetteCtrlDriverV2.pipettePumpAspirateSetParam(AspirationParamId.mix_llf_enable, mixLlfEnable); - pipetteCtrlDriverV2.pipettePumpAspirateSetParam(AspirationParamId.llf_enable, llfEnable); - pipetteCtrlDriverV2.pipettePumpAspirateSetParam(AspirationParamId.mix_volume, mixVolume); - pipetteCtrlDriverV2.pipettePumpAspirateSetParam(AspirationParamId.mix_times, mixTimes); + pipetteCtrlDriverV2.pipettePumpAspirateSetParam(aspirateParam); pipetteCtrlDriverV2.pipettePumpAspirateBlock(); } + public void execDistribute() throws AppException { + pipetteCtrlDriverV2.pipettePumpDistributeAllSetParam(distributeParam); + pipetteCtrlDriverV2.pipettePumpDistributeAllBlock(); + } + public void pipettePumpInitDeviceBlock(Integer cpyId) throws AppException { pipetteCtrlDriverV2.pipettePumpInitDeviceBlock(cpyId); platInfoCpyId = cpyId; @@ -84,18 +158,29 @@ public class PipetteGunOperationCtrlPage { void init() { var page = extApiPageMgr.newPage(this); page.newGroup("配置吸液参数"); - page.addFunction("设置吸取体积", this::setVolume).setParamVal("volume", () -> volume); - page.addFunction("设置容器位置", this::setContainerPos).setParamVal("containerPos", () -> containerPos); - page.addFunction("设置容器信息", this::setContainerInfoIndex).setParamVal("containerInfoIndex", () -> containerInfoIndex); - page.addFunction("设置液体配置", this::setLiquidCfgIndex).setParamVal("liquidCfgIndex", () -> liquidCfgIndex); - page.addFunction("设置吸取模式", this::setAspirationMode).setParamVal("aspirationMode", () -> aspirationMode); - page.addFunction("设置LLDEnable", this::setLldEnable).setParamVal("lldEnable", () -> lldEnable); - page.addFunction("设置LLD类型", this::setLldType).setParamVal("lldType", () -> lldType); - page.addFunction("设置LLD保护模式使能", this::setLldEnableProtect).setParamVal("lldEnableProtect", () -> lldEnableProtect); - page.addFunction("设置吸吐混匀-使能LLF", this::setMixLlfEnable).setParamVal("mixLlfEnable", () -> mixLlfEnable); - page.addFunction("设置吸液-使能LLF", this::setLlfEnable).setParamVal("llfEnable", () -> llfEnable); - page.addFunction("设置混匀体积", this::setMixVolume).setParamVal("mixVolume", () -> mixVolume); - page.addFunction("设置混匀次数", this::setMixTimes).setParamVal("mixTimes", () -> mixTimes); + page.addFunction("设置吸取体积", this::setAspirationParamVolume).setParamVal("volume", () -> aspirateParam.volume); + page.addFunction("设置容器位置", this::setAspirationParamContainerPos).setParamVal("containerPos", () -> aspirateParam.containerPos); + page.addFunction("设置容器信息", this::setAspirationParamContainerInfoIndex).setParamVal("containerInfoIndex", () -> aspirateParam.containerInfoIndex); + page.addFunction("设置液体配置", this::setAspirationParamLiquidCfgIndex).setParamVal("liquidCfgIndex", () -> aspirateParam.liquidCfgIndex); + page.addFunction("设置吸取模式", this::setAspirationParamAspirationMode).setParamVal("aspirationMode", () -> aspirateParam.aspirationMode); + page.addFunction("设置LLDEnable", this::setAspirationParamLldEnable).setParamVal("lldEnable", () -> aspirateParam.lldEnable); + page.addFunction("设置LLD类型", this::setAspirationParamLldType).setParamVal("lldType", () -> aspirateParam.lldType); + page.addFunction("设置LLD保护模式使能", this::setAspirationParamLldEnableProtect).setParamVal("lldEnableProtect", () -> aspirateParam.lldEnableProtect); + page.addFunction("设置吸吐混匀-使能LLF", this::setAspirationParamMixLlfEnable).setParamVal("mixLlfEnable", () -> aspirateParam.mixLlfEnable); + page.addFunction("设置吸液-使能LLF", this::setAspirationParamLlfEnable).setParamVal("llfEnable", () -> aspirateParam.llfEnable); + page.addFunction("设置混匀体积", this::setAspirationParamMixVolume).setParamVal("mixVolume", () -> aspirateParam.mixVolume); + page.addFunction("设置混匀次数", this::setAspirationParamMixTimes).setParamVal("mixTimes", () -> aspirateParam.mixTimes); + + page.newGroup(" 配置分配参数"); + page.addFunction("设置容器位置", this::setDistributeParam_containerPos).setParamVal("containerPos", () -> distributeParam.containerPos); + page.addFunction("设置目标容器配置索引", this::setDistributeParam_destContainerCpyid).setParamVal("destContainerCpyid", () -> distributeParam.destContainerCpyid); + page.addFunction("设置目标容器是否为空", this::setDistributeParam_destContainerIsEmpty).setParamVal("destContainerIsEmpty", () -> distributeParam.destContainerIsEmpty); + page.addFunction("设置目标容器液体配置索引", this::setDistributeParam_destLiquidCfgIndex).setParamVal("destLiquidCfgIndex", () -> distributeParam.destLiquidCfgIndex); + page.addFunction("设置分配类型", this::setDistributeParam_distribuType).setParamVal("distribuType", () -> distributeParam.distribuType); + page.addFunction("设置混匀体积", this::setDistributeParam_mixVolume).setParamVal("mixVolume", () -> distributeParam.mixVolume); + page.addFunction("设置混匀次数", this::setDistributeParam_mixTimes).setParamVal("mixTimes", () -> distributeParam.mixTimes); + page.addFunction("设置自动归零", this::setDistributeParam_zmAutoMoveToZero).setParamVal("zmAutoMoveToZero", () -> distributeParam.zmAutoMoveToZero); + page.newGroup(" 操作"); page.addFunction("初始化设备", this::pipettePumpInitDeviceBlock) .setParamVal("cpyId", () -> platInfoCpyId); @@ -103,7 +188,9 @@ public class PipetteGunOperationCtrlPage { page.addFunction("放回Tip", this::pipettePumpPutBakTip); page.addFunction("丢Tip", this::pipettePumpDepositTip); page.addFunction("刺破", this::pipettePumpPierceThroughBlock); - page.addFunction("执行吸取", this::execAspirate); + page.addFunction("吸取", this::execAspirate); + page.addFunction("分配全部", this::execDistribute); + extApiPageMgr.addPage(page); }