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

update

master
zhaohe 2 months ago
parent
732f5942bc
commit
bddff84757
8 changed files with 353 additions and 161 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. 176
      src/main/java/a8k/app/hardware/driver/PipetteCtrlDriverV2.java
  2. 7
      src/main/java/a8k/app/hardware/type/pipette_module/cfg/LiquidInfoIndex.java
  3. 54
      src/main/java/a8k/app/hardware/type/pipette_module/cfgbean/PipetteContainerInfo.java
  4. 66
      src/main/java/a8k/app/hardware/type/pipette_module/cfgbean/PipetteLiquidInfo.java
  5. 52
      src/main/java/a8k/app/hardware/type/pipette_module/cfgbean/PipettePMVCfg.java
  6. 53
      src/main/java/a8k/app/hardware/type/pipette_module/cfgbean/PipettePlatInfo.java
  7. 55
      src/main/java/a8k/app/hardware/type/pipette_module/cfgbean/PipetteZMBCfg.java
  8. 51
      src/main/java/a8k/app/hardware/type/pipette_module/cfgbean/PipetteZMVCfg.java

176
src/main/java/a8k/app/hardware/driver/PipetteCtrlDriverV2.java
View File

@ -367,195 +367,59 @@ public class PipetteCtrlDriverV2 {
canBus.waitForMod(MId.PipetteMod, actionOvertimeConstant.get(MId.PipetteMod, action));
}
//
// Config
//
public void applyLiquidInfo(LiquidConfigCpyIdx cpyIdx, PipetteLiquidInfo val) throws AppException {
val.serialization((index, itermVal) -> setLiquidInfo(cpyIdx.toInteger(), index, itermVal));
}
public PipetteLiquidInfo getLiquidInfo(LiquidConfigCpyIdx cpyIdx) throws AppException {
return PipetteLiquidInfo.build((LiquidInfoIndex index) -> getLiquidInfo(cpyIdx.toInteger(), index));
}
public void applyPlatInfo(Integer cpyIdx, PipettePlatInfo val) throws AppException {
setPlatInfo(cpyIdx, PlatformInfoIndex.workRefPos, val.workRefPos);
setPlatInfo(cpyIdx, PlatformInfoIndex.tipPickingPos, val.tipPickingPos);
setPlatInfo(cpyIdx, PlatformInfoIndex.tipPickingSearchRange, val.tipPickingSearchRange);
setPlatInfo(cpyIdx, PlatformInfoIndex.tipPickingAppendDistance, val.tipPickingAppendDistance);
setPlatInfo(cpyIdx, PlatformInfoIndex.tipDepositPos, val.tipDepositPos);
setPlatInfo(cpyIdx, PlatformInfoIndex.transformPos, val.transformPos);
setPlatInfo(cpyIdx, PlatformInfoIndex.tipType, val.tipType);
setPlatInfo(cpyIdx, PlatformInfoIndex.tipLength, val.tipLength);
val.serialization((index, itermVal) -> setPlatInfo(cpyIdx, index, itermVal));
}
public PipettePlatInfo getPlatInfo(Integer cpyIdx) throws AppException {
PipettePlatInfo val = new PipettePlatInfo();
val.workRefPos = getPlatInfo(cpyIdx, PlatformInfoIndex.workRefPos);
val.tipPickingPos = getPlatInfo(cpyIdx, PlatformInfoIndex.tipPickingPos);
val.tipPickingSearchRange = getPlatInfo(cpyIdx, PlatformInfoIndex.tipPickingSearchRange);
val.tipPickingAppendDistance = getPlatInfo(cpyIdx, PlatformInfoIndex.tipPickingAppendDistance);
val.tipDepositPos = getPlatInfo(cpyIdx, PlatformInfoIndex.tipDepositPos);
val.transformPos = getPlatInfo(cpyIdx, PlatformInfoIndex.transformPos);
val.tipType = getPlatInfo(cpyIdx, PlatformInfoIndex.tipType);
val.tipLength = getPlatInfo(cpyIdx, PlatformInfoIndex.tipLength);
val.mark = getPlatInfo(cpyIdx, PlatformInfoIndex.mark);
return val;
return PipettePlatInfo.build((PlatformInfoIndex index) -> getPlatInfo(cpyIdx, index));
}
public void applyContainerInfo(ContainerCpyId cpyIdx, PipetteContainerInfo val) throws AppException {
setContainerInfo(cpyIdx, ContainerInfoIndex.containerType, val.containerType);
setContainerInfo(cpyIdx, ContainerInfoIndex.containerNeckPos, val.containerNeckPos);
setContainerInfo(cpyIdx, ContainerInfoIndex.containerDepth, val.containerDepth);
setContainerInfo(cpyIdx, ContainerInfoIndex.containerRound, val.containerRound);
setContainerInfo(cpyIdx, ContainerInfoIndex.containerBottomSectionHeight, val.containerBottomSectionHeight);
setContainerInfo(cpyIdx, ContainerInfoIndex.immersionDepth, val.immersionDepth);
setContainerInfo(cpyIdx, ContainerInfoIndex.leavingHeight, val.leavingHeight);
setContainerInfo(cpyIdx, ContainerInfoIndex.jetHeight, val.jetHeight);
setContainerInfo(cpyIdx, ContainerInfoIndex.lldStartSearchDepth, val.lldStartSearchDepth);
setContainerInfo(cpyIdx, ContainerInfoIndex.fixAspirationDepth, val.fixAspirationDepth);
setContainerInfo(cpyIdx, ContainerInfoIndex.llfVConvertCoefficient, val.llfVConvertCoefficient);
setContainerInfo(cpyIdx, ContainerInfoIndex.pierceDepth, val.pierceDepth);
val.serialization((index, itermVal) -> setContainerInfo(cpyIdx.toInteger(), index, itermVal));
}
public PipetteContainerInfo getContainerInfo(ContainerCpyId cpyIdx) throws AppException {
PipetteContainerInfo val = new PipetteContainerInfo();
val.containerType = getContainerInfo(cpyIdx, ContainerInfoIndex.containerType);
val.containerNeckPos = getContainerInfo(cpyIdx, ContainerInfoIndex.containerNeckPos);
val.containerDepth = getContainerInfo(cpyIdx, ContainerInfoIndex.containerDepth);
val.containerRound = getContainerInfo(cpyIdx, ContainerInfoIndex.containerRound);
val.containerBottomSectionHeight = getContainerInfo(cpyIdx, ContainerInfoIndex.containerBottomSectionHeight);
val.immersionDepth = getContainerInfo(cpyIdx, ContainerInfoIndex.immersionDepth);
val.leavingHeight = getContainerInfo(cpyIdx, ContainerInfoIndex.leavingHeight);
val.jetHeight = getContainerInfo(cpyIdx, ContainerInfoIndex.jetHeight);
val.lldStartSearchDepth = getContainerInfo(cpyIdx, ContainerInfoIndex.lldStartSearchDepth);
val.fixAspirationDepth = getContainerInfo(cpyIdx, ContainerInfoIndex.fixAspirationDepth);
val.llfVConvertCoefficient = getContainerInfo(cpyIdx, ContainerInfoIndex.llfVConvertCoefficient);
val.pierceDepth = getContainerInfo(cpyIdx, ContainerInfoIndex.pierceDepth);
val.mark = getContainerInfo(cpyIdx, ContainerInfoIndex.mark);
return val;
return PipetteContainerInfo.build((ContainerInfoIndex index) -> getContainerInfo(cpyIdx.toInteger(), index));
}
public void applyLiquidInfo(LiquidConfigCpyIdx cpyIdx, PipetteLiquidInfo val) throws AppException {
setLiquidInfo(cpyIdx, LiquidInfoIndex.plldPmVCpyId, val.plldPmVCpyId);
setLiquidInfo(cpyIdx, LiquidInfoIndex.plldThreshold, val.plldThreshold);
setLiquidInfo(cpyIdx, LiquidInfoIndex.plldZmVel, val.plldZmVel);
setLiquidInfo(cpyIdx, LiquidInfoIndex.emptyTipPmVCpyId, val.emptyTipPmVCpyId);
setLiquidInfo(cpyIdx, LiquidInfoIndex.blowoutAirVolume, val.blowoutAirVolume);
setLiquidInfo(cpyIdx, LiquidInfoIndex.blowoutAirPmVCpyId, val.blowoutAirPmVCpyId);
setLiquidInfo(cpyIdx, LiquidInfoIndex.overAspiratedVolume, val.overAspiratedVolume);
setLiquidInfo(cpyIdx, LiquidInfoIndex.overAspiratedPmVCpyId, val.overAspiratedPmVCpyId);
setLiquidInfo(cpyIdx, LiquidInfoIndex.aspirationPmVCpyIdLow, val.aspirationPmVCpyIdLow);
setLiquidInfo(cpyIdx, LiquidInfoIndex.aspirationPmVCpyIdHigh, val.aspirationPmVCpyIdHigh);
setLiquidInfo(cpyIdx, LiquidInfoIndex.aspirationVolumeBreakVal, val.aspirationVolumeBreakVal);
setLiquidInfo(cpyIdx, LiquidInfoIndex.volumeCalibrationCoefficientB, val.volumeCalibrationCoefficientB);
setLiquidInfo(cpyIdx, LiquidInfoIndex.volumeCalibrationCoefficientK, val.volumeCalibrationCoefficientK);
setLiquidInfo(cpyIdx, LiquidInfoIndex.settlingTime, val.settlingTime);
setLiquidInfo(cpyIdx, LiquidInfoIndex.transportVolume, val.transportVolume);
setLiquidInfo(cpyIdx, LiquidInfoIndex.transportVolumePmVCpyId, val.transportVolumePmVCpyId);
setLiquidInfo(cpyIdx, LiquidInfoIndex.mixPmVCpyId, val.mixPmVCpyId);
}
public PipetteLiquidInfo getLiquidInfo(LiquidConfigCpyIdx cpyIdx) throws AppException {
PipetteLiquidInfo val = new PipetteLiquidInfo();
val.plldPmVCpyId = getLiquidInfo(cpyIdx, LiquidInfoIndex.plldPmVCpyId);
val.plldThreshold = getLiquidInfo(cpyIdx, LiquidInfoIndex.plldThreshold);
val.plldZmVel = getLiquidInfo(cpyIdx, LiquidInfoIndex.plldZmVel);
val.emptyTipPmVCpyId = getLiquidInfo(cpyIdx, LiquidInfoIndex.emptyTipPmVCpyId);
val.blowoutAirVolume = getLiquidInfo(cpyIdx, LiquidInfoIndex.blowoutAirVolume);
val.blowoutAirPmVCpyId = getLiquidInfo(cpyIdx, LiquidInfoIndex.blowoutAirPmVCpyId);
val.overAspiratedVolume = getLiquidInfo(cpyIdx, LiquidInfoIndex.overAspiratedVolume);
val.overAspiratedPmVCpyId = getLiquidInfo(cpyIdx, LiquidInfoIndex.overAspiratedPmVCpyId);
val.aspirationPmVCpyIdLow = getLiquidInfo(cpyIdx, LiquidInfoIndex.aspirationPmVCpyIdLow);
val.aspirationPmVCpyIdHigh = getLiquidInfo(cpyIdx, LiquidInfoIndex.aspirationPmVCpyIdHigh);
val.aspirationVolumeBreakVal = getLiquidInfo(cpyIdx, LiquidInfoIndex.aspirationVolumeBreakVal);
val.volumeCalibrationCoefficientB = getLiquidInfo(cpyIdx, LiquidInfoIndex.volumeCalibrationCoefficientB);
val.volumeCalibrationCoefficientK = getLiquidInfo(cpyIdx, LiquidInfoIndex.volumeCalibrationCoefficientK);
val.settlingTime = getLiquidInfo(cpyIdx, LiquidInfoIndex.settlingTime);
val.transportVolume = getLiquidInfo(cpyIdx, LiquidInfoIndex.transportVolume);
val.transportVolumePmVCpyId = getLiquidInfo(cpyIdx, LiquidInfoIndex.transportVolumePmVCpyId);
val.mixPmVCpyId = getLiquidInfo(cpyIdx, LiquidInfoIndex.mixPmVCpyId);
val.mark = getLiquidInfo(cpyIdx, LiquidInfoIndex.mark);
return val;
}
public void setPMVCfg(PMVCpyIdx idx, PipettePMVCfg val) throws AppException {
setPMVCfg(idx, PMVConfigIndex.acc, val.acc);
setPMVCfg(idx, PMVConfigIndex.dec, val.dec);
setPMVCfg(idx, PMVConfigIndex.vStart, val.vStart);
setPMVCfg(idx, PMVConfigIndex.vStop, val.vStop);
setPMVCfg(idx, PMVConfigIndex.vMax, val.vMax);
val.serialization((index, itermVal) -> setPMVCfg(idx, index, itermVal));
}
public PipettePMVCfg getPMVCfg(PMVCpyIdx idx) throws AppException {
PipettePMVCfg val = new PipettePMVCfg();
val.acc = getPMVCfg(idx, PMVConfigIndex.acc);
val.dec = getPMVCfg(idx, PMVConfigIndex.dec);
val.vStart = getPMVCfg(idx, PMVConfigIndex.vStart);
val.vStop = getPMVCfg(idx, PMVConfigIndex.vStop);
val.vMax = getPMVCfg(idx, PMVConfigIndex.vMax);
val.mark = getPMVCfg(idx, PMVConfigIndex.mark);
return val;
return PipettePMVCfg.build((PMVConfigIndex index) -> getPMVCfg(idx, index));
}
public void setZMBCfg(PipetteZMBCfg val) throws AppException {
setZMBCfg(ZMBasicConfigIndex.shaft, val.shaft);
setZMBCfg(ZMBasicConfigIndex.oneCirclePulse, val.oneCirclePulse);
setZMBCfg(ZMBasicConfigIndex.oneCirclePulseDenominator, val.oneCirclePulseDenominator);
setZMBCfg(ZMBasicConfigIndex.ihold, val.ihold);
setZMBCfg(ZMBasicConfigIndex.irun, val.irun);
setZMBCfg(ZMBasicConfigIndex.iholddelay, val.iholddelay);
setZMBCfg(ZMBasicConfigIndex.iglobalscaler, val.iglobalscaler);
setZMBCfg(ZMBasicConfigIndex.mind, val.minD);
setZMBCfg(ZMBasicConfigIndex.maxd, val.maxD);
setZMBCfg(ZMBasicConfigIndex.tzerowait, val.tzerowait);
setZMBCfg(ZMBasicConfigIndex.encResolution, val.encResolution);
setZMBCfg(ZMBasicConfigIndex.enableEnc, val.enableEnc);
setZMBCfg(ZMBasicConfigIndex.dzero, val.dzero);
setZMBCfg(ZMBasicConfigIndex.ioTriggerAppendDistance, val.ioTriggerAppendDistance);
setZMBCfg(ZMBasicConfigIndex.posDeviTolerance, val.posDeviTolerance);
setZMBCfg(ZMBasicConfigIndex.mres, val.mres);
val.serialization(this::setZMBCfg);
}
public PipetteZMBCfg getZMBCfg() throws AppException {
PipetteZMBCfg val = new PipetteZMBCfg();
val.shaft = getZMBCfg(ZMBasicConfigIndex.shaft);
val.oneCirclePulse = getZMBCfg(ZMBasicConfigIndex.oneCirclePulse);
val.oneCirclePulseDenominator = getZMBCfg(ZMBasicConfigIndex.oneCirclePulseDenominator);
val.ihold = getZMBCfg(ZMBasicConfigIndex.ihold);
val.irun = getZMBCfg(ZMBasicConfigIndex.irun);
val.iholddelay = getZMBCfg(ZMBasicConfigIndex.iholddelay);
val.iglobalscaler = getZMBCfg(ZMBasicConfigIndex.iglobalscaler);
val.minD = getZMBCfg(ZMBasicConfigIndex.mind);
val.maxD = getZMBCfg(ZMBasicConfigIndex.maxd);
val.tzerowait = getZMBCfg(ZMBasicConfigIndex.tzerowait);
val.encResolution = getZMBCfg(ZMBasicConfigIndex.encResolution);
val.enableEnc = getZMBCfg(ZMBasicConfigIndex.enableEnc);
val.dzero = getZMBCfg(ZMBasicConfigIndex.dzero);
val.ioTriggerAppendDistance = getZMBCfg(ZMBasicConfigIndex.ioTriggerAppendDistance);
val.posDeviTolerance = getZMBCfg(ZMBasicConfigIndex.posDeviTolerance);
val.mres = getZMBCfg(ZMBasicConfigIndex.mres);
val.mark = getZMBCfg(ZMBasicConfigIndex.mark);
return val;
return PipetteZMBCfg.build(this::getZMBCfg);
}
public void setZMVCfg(ZMVCpyIdx idx, PipetteZMVCfg val) throws AppException {
setZMVCfg(idx, ZMVConfigIndex.vstart, val.vstart);
setZMVCfg(idx, ZMVConfigIndex.a1, val.a1);
setZMVCfg(idx, ZMVConfigIndex.amax, val.amax);
setZMVCfg(idx, ZMVConfigIndex.v1, val.v1);
setZMVCfg(idx, ZMVConfigIndex.dmax, val.dmax);
setZMVCfg(idx, ZMVConfigIndex.d1, val.d1);
setZMVCfg(idx, ZMVConfigIndex.vstop, val.vstop);
setZMVCfg(idx, ZMVConfigIndex.vmax, val.vmax);
val.serialization((index, itermVal) -> setZMVCfg(idx, index, itermVal));
}
public PipetteZMVCfg getZMVCfg(ZMVCpyIdx idx) throws AppException {
PipetteZMVCfg val = new PipetteZMVCfg();
val.vstart = getZMVCfg(idx, ZMVConfigIndex.vstart);
val.a1 = getZMVCfg(idx, ZMVConfigIndex.a1);
val.amax = getZMVCfg(idx, ZMVConfigIndex.amax);
val.v1 = getZMVCfg(idx, ZMVConfigIndex.v1);
val.dmax = getZMVCfg(idx, ZMVConfigIndex.dmax);
val.d1 = getZMVCfg(idx, ZMVConfigIndex.d1);
val.vstop = getZMVCfg(idx, ZMVConfigIndex.vstop);
val.vmax = getZMVCfg(idx, ZMVConfigIndex.vmax);
val.mark = getZMVCfg(idx, ZMVConfigIndex.mark);
return val;
return PipetteZMVCfg.build((ZMVConfigIndex index) -> getZMVCfg(idx, index));
}
public PipetteConfig getConfig() throws AppException {

7
src/main/java/a8k/app/hardware/type/pipette_module/cfg/LiquidInfoIndex.java
View File

@ -60,8 +60,13 @@ public enum LiquidInfoIndex {
// // 混匀pm速率
// //
mixPmVCpyId, // 混匀时泵机速率配置
//
// 分配配置
//
jetPmVCpyId, // 喷射时泵机速率配置 jet_pm_vcpyid
distributePmVCpyId, // 分配时泵机速率配置 distribu_pm_vpyid
mark,
;
;
public Integer toInteger() {
return ordinal();

54
src/main/java/a8k/app/hardware/type/pipette_module/cfgbean/PipetteContainerInfo.java
View File

@ -1,5 +1,10 @@
package a8k.app.hardware.type.pipette_module.cfgbean;
import a8k.app.hardware.type.pipette_module.cfg.ContainerInfoIndex;
import a8k.app.type.exception.AppException;
import java.lang.reflect.Field;
public class PipetteContainerInfo {
public Integer containerType = 0; // 容器类型 0:平面 1:flat(平底) 2:conical(锥底) 3:round(圆底)
public Integer containerNeckPos = 0; // 容器,瓶口位置(相对位置0.1mm) !discard 废弃不再使用
@ -14,4 +19,53 @@ public class PipetteContainerInfo {
public Integer llfVConvertCoefficient = 0; // 液面跟随转换系数 0.0001 llf_zm_vel = aspiration_pm_vel * llf_vconvert_coneff * 0.0001
public Integer pierceDepth = 0; // 穿刺深度(0.1mm)，用于刺破容器防尘膜
public Integer mark = 0; // 结构体最后一个数值，设置9973，用于保证单片机端和java端均正确更新了枚举
@FunctionalInterface
public interface AssignObjectItemFn {
Integer assignVal(ContainerInfoIndex index) throws AppException;
}
@FunctionalInterface
public interface SerializationObjectItemFn {
void serializeObject(ContainerInfoIndex index, Integer itermVal) throws AppException;
}
public static PipetteContainerInfo build(AssignObjectItemFn assignFn) throws AppException {
PipetteContainerInfo info = new PipetteContainerInfo();
info.assignObject(assignFn);
return info;
}
public void assignObject(AssignObjectItemFn assignFn) throws AppException {
for (ContainerInfoIndex idx : ContainerInfoIndex.values()) {
try {
PipetteContainerInfo.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 (ContainerInfoIndex idx : ContainerInfoIndex.values()) {
try {
Integer val = (Integer) PipetteContainerInfo.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 {
PipetteContainerInfo info = new PipetteContainerInfo();
info.assignObject(Enum::ordinal);
info.serialization((index, val) -> {
System.out.println("Index: " + index + ", Value: " + val);
});
}
}

66
src/main/java/a8k/app/hardware/type/pipette_module/cfgbean/PipetteLiquidInfo.java
View File

@ -1,6 +1,13 @@
package a8k.app.hardware.type.pipette_module.cfgbean;
import a8k.app.hardware.type.pipette_module.cfg.LiquidInfoIndex;
import a8k.app.type.exception.AppException;
import java.lang.reflect.Field;
public class PipetteLiquidInfo {
/**
* @brief
*
@ -82,6 +89,61 @@ public class PipetteLiquidInfo {
//
// 混匀pm速率
//
public Integer mixPmVCpyId = 0; // 混匀时泵机速率配置
public Integer mark = 0; // 结构体最后一个数值，设置9973，用于保证单片机端和java端均正确更新了枚举
public Integer mixPmVCpyId = 0; // 混匀时泵机速率配置
//
// 分配配置
//
public Integer jetPmVCpyId = 0; // 喷射时泵机速率配置 jet_pm_vcpyid
public Integer distributePmVCpyId = 0; // 分配时泵机速率配置 distribu_pm_vpyid
public Integer mark = 0; // 结构体最后一个数值，设置9973，用于保证单片机端和java端均正确更新了枚举
@FunctionalInterface
public interface AssignObjectItemFn {
Integer assignVal(LiquidInfoIndex index) throws AppException;
}
@FunctionalInterface
public interface SerializationObjectItemFn {
void serializeObject(LiquidInfoIndex index, Integer itermVal) throws AppException;
}
public static PipetteLiquidInfo build(AssignObjectItemFn assignFn) throws AppException {
PipetteLiquidInfo info = new PipetteLiquidInfo();
info.assignObject(assignFn);
return info;
}
public void assignObject(AssignObjectItemFn assignFn) throws AppException {
for (LiquidInfoIndex idx : LiquidInfoIndex.values()) {
try {
PipetteLiquidInfo.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 (LiquidInfoIndex idx : LiquidInfoIndex.values()) {
try {
Integer val = (Integer) PipetteLiquidInfo.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 {
PipetteLiquidInfo info = new PipetteLiquidInfo();
info.assignObject(Enum::ordinal);
info.serialization((index, val) -> {
System.out.println("Index: " + index + ", Value: " + val);
});
}
}

52
src/main/java/a8k/app/hardware/type/pipette_module/cfgbean/PipettePMVCfg.java
View File

@ -1,5 +1,10 @@
package a8k.app.hardware.type.pipette_module.cfgbean;
import a8k.app.hardware.type.pipette_module.cfg.PMVConfigIndex;
import a8k.app.type.exception.AppException;
import java.lang.reflect.Field;
public class PipettePMVCfg {
public Integer acc = 0;
public Integer dec = 0;
@ -7,4 +12,51 @@ public class PipettePMVCfg {
public Integer vStop = 0;
public Integer vMax = 0;
public Integer mark = 0; // 结构体最后一个数值，设置9973，用于保证单片机端和java端均正确更新了枚举
@FunctionalInterface
public interface AssignObjectItemFn {
Integer assignVal(PMVConfigIndex index) throws AppException;
}
@FunctionalInterface
public interface SerializationObjectItemFn {
void serializeObject(PMVConfigIndex index, Integer itermVal) throws AppException;
}
public static PipettePMVCfg build(AssignObjectItemFn assignFn) throws AppException {
PipettePMVCfg info = new PipettePMVCfg();
info.assignObject(assignFn);
return info;
}
public void assignObject(AssignObjectItemFn assignFn) throws AppException {
for (PMVConfigIndex idx : PMVConfigIndex.values()) {
try {
PipettePMVCfg.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 (PMVConfigIndex idx : PMVConfigIndex.values()) {
try {
Integer val = (Integer) PipettePMVCfg.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 {
PipettePMVCfg info = new PipettePMVCfg();
info.assignObject(Enum::ordinal);
info.serialization((index, val) -> {
System.out.println("Index: " + index + ", Value: " + val);
});
}
}

53
src/main/java/a8k/app/hardware/type/pipette_module/cfgbean/PipettePlatInfo.java
View File

@ -1,5 +1,10 @@
package a8k.app.hardware.type.pipette_module.cfgbean;
import a8k.app.hardware.type.pipette_module.cfg.PlatformInfoIndex;
import a8k.app.type.exception.AppException;
import java.lang.reflect.Field;
public class PipettePlatInfo {
/**
* @brief 工作参考平面
@ -27,4 +32,52 @@ public class PipettePlatInfo {
public Integer tipLength = 0; // tip长度
public Integer mark = 0; // 结构体最后一个数值，设置9973，用于保证单片机端和java端均正确更新了枚举
@FunctionalInterface
public interface AssignObjectItemFn {
Integer assignVal(PlatformInfoIndex index) throws AppException;
}
@FunctionalInterface
public interface SerializationObjectItemFn {
void serializeObject(PlatformInfoIndex index, Integer itermVal) throws AppException;
}
public static PipettePlatInfo build(AssignObjectItemFn assignFn) throws AppException {
PipettePlatInfo info = new PipettePlatInfo();
info.assignObject(assignFn);
return info;
}
public void assignObject(AssignObjectItemFn assignFn) throws AppException {
for (PlatformInfoIndex idx : PlatformInfoIndex.values()) {
try {
PipettePlatInfo.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 (PlatformInfoIndex idx : PlatformInfoIndex.values()) {
try {
Integer val = (Integer) PipettePlatInfo.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 {
PipettePlatInfo info = new PipettePlatInfo();
info.assignObject(Enum::ordinal);
info.serialization((index, val) -> {
System.out.println("Index: " + index + ", Value: " + val);
});
}
}

55
src/main/java/a8k/app/hardware/type/pipette_module/cfgbean/PipetteZMBCfg.java
View File

@ -1,5 +1,8 @@
package a8k.app.hardware.type.pipette_module.cfgbean;
import a8k.app.hardware.type.pipette_module.cfg.ZMBasicConfigIndex;
import a8k.app.type.exception.AppException;
public class PipetteZMBCfg {
public Integer shaft = 0; // Z轴电机运动方向调整
public Integer oneCirclePulse = 0; // 电子齿轮比-分子
@ -8,8 +11,8 @@ public class PipetteZMBCfg {
public Integer irun = 0; //
public Integer iholddelay = 0; //
public Integer iglobalscaler = 0; //
public Integer minD = 0; //
public Integer maxD = 0; //
public Integer mind = 0; //
public Integer maxd = 0; //
public Integer tzerowait = 0; //
public Integer encResolution = 0; //
public Integer enableEnc = 0; //
@ -18,4 +21,52 @@ public class PipetteZMBCfg {
public Integer posDeviTolerance = 0; //
public Integer mres = 0; //
public Integer mark = 0; // 结构体最后一个数值，设置9973，用于保证单片机端和java端均正确更新了枚举
@FunctionalInterface
public interface AssignObjectItemFn {
Integer assignVal(ZMBasicConfigIndex index) throws AppException;
}
@FunctionalInterface
public interface SerializationObjectItemFn {
void serializeObject(ZMBasicConfigIndex index, Integer itermVal) throws AppException;
}
public static PipetteZMBCfg build(AssignObjectItemFn assignFn) throws AppException {
PipetteZMBCfg info = new PipetteZMBCfg();
info.assignObject(assignFn);
return info;
}
public void assignObject(AssignObjectItemFn assignFn) throws AppException {
for (ZMBasicConfigIndex idx : ZMBasicConfigIndex.values()) {
try {
PipetteZMBCfg.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 (ZMBasicConfigIndex idx : ZMBasicConfigIndex.values()) {
try {
Integer val = (Integer) PipetteZMBCfg.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 {
PipetteZMBCfg info = new PipetteZMBCfg();
info.assignObject(Enum::ordinal);
info.serialization((index, val) -> {
System.out.println("Index: " + index + ", Value: " + val);
});
}
}

51
src/main/java/a8k/app/hardware/type/pipette_module/cfgbean/PipetteZMVCfg.java
View File

@ -1,5 +1,8 @@
package a8k.app.hardware.type.pipette_module.cfgbean;
import a8k.app.hardware.type.pipette_module.cfg.ZMVConfigIndex;
import a8k.app.type.exception.AppException;
public class PipetteZMVCfg {
public Integer vstart = 0;
public Integer a1 = 0;
@ -10,4 +13,52 @@ public class PipetteZMVCfg {
public Integer vstop = 0;
public Integer vmax = 0;
public Integer mark = 0; // 结构体最后一个数值，设置9973，用于保证单片机端和java端均正确更新了枚举
@FunctionalInterface
public interface AssignObjectItemFn {
Integer assignVal(ZMVConfigIndex index) throws AppException;
}
@FunctionalInterface
public interface SerializationObjectItemFn {
void serializeObject(ZMVConfigIndex index, Integer itermVal) throws AppException;
}
public static PipetteZMVCfg build(AssignObjectItemFn assignFn) throws AppException {
PipetteZMVCfg info = new PipetteZMVCfg();
info.assignObject(assignFn);
return info;
}
public void assignObject(AssignObjectItemFn assignFn) throws AppException {
for (ZMVConfigIndex idx : ZMVConfigIndex.values()) {
try {
PipetteZMVCfg.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 (ZMVConfigIndex idx : ZMVConfigIndex.values()) {
try {
Integer val = (Integer) PipetteZMVCfg.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 {
PipetteZMVCfg info = new PipetteZMVCfg();
info.assignObject(Enum::ordinal);
info.serialization((index, val) -> {
System.out.println("Index: " + index + ", Value: " + val);
});
}
}
Write Preview
Loading…
Cancel
Save