update

src/main/java/a8k/app/config/A8kSubModuleInitRegConfig.java

@@ -105,9 +105,9 @@ public class A8kSubModuleInitRegConfig {
 
 
 		//WaterCoolingTemperatureCtrl
-		addRegMarker(ModuleType.WaterCoolingTempCtrl, RegIndex.kreg_water_cooling_tmp_controler_pid_target);
-		addRegMarker(ModuleType.WaterCoolingTempCtrl, RegIndex.kreg_water_cooling_tmp_controler_pid_nowoutput);
-		addRegMarker(ModuleType.WaterCoolingTempCtrl, RegIndex.kreg_water_cooling_tmp_controler_pid_feedbackval);
+//		addRegMarker(ModuleType.WaterCoolingTempCtrl, RegIndex.kreg_water_cooling_tmp_controler_pid_target);
+//		addRegMarker(ModuleType.WaterCoolingTempCtrl, RegIndex.kreg_water_cooling_tmp_controler_pid_nowoutput);
+//		addRegMarker(ModuleType.WaterCoolingTempCtrl, RegIndex.kreg_water_cooling_tmp_controler_pid_feedbackval);
 		addRegMarker(ModuleType.WaterCoolingTempCtrl, RegIndex.kreg_water_cooling_tmp_controler_pid_kp);
 		addRegMarker(ModuleType.WaterCoolingTempCtrl, RegIndex.kreg_water_cooling_tmp_controler_pid_ki);
 		addRegMarker(ModuleType.WaterCoolingTempCtrl, RegIndex.kreg_water_cooling_tmp_controler_pid_kd);
@@ -154,10 +154,10 @@ public class A8kSubModuleInitRegConfig {
 		addRegMarker(ModuleType.PipetteGunCtrl, RegIndex.kreg_pipette_zm_io_trigger_append_distance);
 		addRegMarker(ModuleType.PipetteGunCtrl, RegIndex.kreg_pipette_zm_mres);
 
-		addRegMarker(ModuleType.A8kOptical, RegIndex.kreg_a8k_opt_t_pos_offset);
-		addRegMarker(ModuleType.A8kOptical, RegIndex.kreg_a8k_opt_f_pos_offset);
-		addRegMarker(ModuleType.A8kOptical, RegIndex.kreg_a8k_opt_t_reverse_scan_pos_offset);
-		addRegMarker(ModuleType.A8kOptical, RegIndex.kreg_a8k_opt_f_reverse_scan_pos_offset);
+		//		addRegMarker(ModuleType.A8kOptical, RegIndex.kreg_a8k_opt_t_pos_offset);
+		//		addRegMarker(ModuleType.A8kOptical, RegIndex.kreg_a8k_opt_f_pos_offset);
+		//		addRegMarker(ModuleType.A8kOptical, RegIndex.kreg_a8k_opt_t_reverse_scan_pos_offset);
+		//		addRegMarker(ModuleType.A8kOptical, RegIndex.kreg_a8k_opt_f_reverse_scan_pos_offset);
 		addRegMarker(ModuleType.A8kOptical, RegIndex.kreg_a8k_opt_scan_step_interval);
 		addRegMarker(ModuleType.A8kOptical, RegIndex.kreg_a8k_opt_scan_pointnum);
 		addRegMarker(ModuleType.A8kOptical, RegIndex.kreg_a8k_opt_scan_vdefault);

src/main/java/a8k/app/hardware/driver/OptModuleDriver.java

@@ -45,7 +45,7 @@ public class OptModuleDriver {
 			var          packet = A8kPacketFactory.buildCMDPacket(MId.OptMod.toInt(), CmdId.module_get_status.toInt(), ZList.of());
 			ModuleStatus statu  = null;
 			try {
-				statu = ModuleStatus.valueOf(canBus.send(packet, 1000).getContentI32(0));
+				statu = ModuleStatus.valueOf(canBus.send(packet, 50).getContentI32(0));
 			} catch (Exception ignored) {
 			}
 
@@ -62,7 +62,7 @@ public class OptModuleDriver {
 			if (System.currentTimeMillis() - startedAt > overtime) {
 				throw AppException.of(new AEHardwareError(A8kEcode.LOW_ERROR_ACTION_OVERTIME, MId.OptMod, CmdId.a8k_opt_v2_t_start_scan));
 			}
-			OS.forceSleep(1000);
+			OS.forceSleep(100);
 		} while (true);
 
 	}
@@ -72,16 +72,20 @@ public class OptModuleDriver {
 		log.info("OptTStartScan scanDirection:{} lasterGain:{} scanGain:{}", scanDirection, lasterGain, scanGain);
 		canBus.callcmd(MId.OptMod, CmdId.a8k_opt_v2_t_start_scan, scanDirection.getInteger(), lasterGain, scanGain);
 		//TODO: 2024-10-26 zhaohe,修改底层，光学结束上报一条完成事件
-		OS.forceSleep(1000);
+		long startedAt = System.currentTimeMillis();
+		OS.forceSleep(100);
 		waittingForOptFinish(10 * 1000);
+		log.info("opt t scan use {}s", (System.currentTimeMillis() - startedAt) / 1000.0);
 	}
 
 	public void optFStartScan(OptScanDirection scanDirection, Integer lasterGain, Integer scanGain) throws AppException {
 		log.info("OptFStartScan scanDirection:{} lasterGain:{} scanGain:{}", scanDirection, lasterGain, scanGain);
 		canBus.callcmd(MId.OptMod, CmdId.a8k_opt_v2_f_start_scan, scanDirection.getInteger(), lasterGain, scanGain);
 		//TODO: 2024-10-26 zhaohe,修改底层，光学结束上报一条完成事件
-		OS.forceSleep(1000);
+		long startedAt = System.currentTimeMillis();
+		OS.forceSleep(100);
 		waittingForOptFinish(10 * 1000);
+		log.info("opt f scan use {}s", (System.currentTimeMillis() - startedAt) /  1000.0);
 	}
 
 	public Integer[] optReadRaw() throws AppException {

src/main/java/a8k/app/hardware/driver/StepMotorCtrlDriver.java

@@ -35,6 +35,10 @@ public class StepMotorCtrlDriver {
 		canBus.callcmd(id.mid, CmdId.step_motor_easy_move_to_zero);
 	}
 
+	public void setCurrentPos(StepMotorMId id, Integer pos) throws AppException {
+		canBus.callcmd(id.mid, CmdId.step_motor_easy_set_current_pos, pos);
+	}
+
 	void stepMotorEasyMoveToZeroPointQuick(StepMotorMId id) throws AppException {
 		canBus.callcmd(id.mid, CmdId.step_motor_easy_move_to_zero_point_quick);
 	}

src/main/java/a8k/app/service/lowerctrl/TurnableMoveCtrlService.java

@@ -3,6 +3,7 @@ package a8k.app.service.lowerctrl;
 import a8k.app.hardware.driver.InputDetectDriver;
 import a8k.app.hardware.driver.StepMotorCtrlDriver;
 import a8k.app.hardware.type.StepMotorMId;
+import a8k.app.hardware.type.StepMotorRegIndex;
 import a8k.app.service.param.pos.TurntablePosParamMgr;
 import a8k.app.type.a8k.pos.IncubatorPos;
 import a8k.app.type.exception.AppException;
@@ -10,6 +11,7 @@ import a8k.app.hardware.channel.A8kCanBusService;
 import a8k.app.hardware.type.A8kEcode;
 import a8k.app.hardware.type.InputIOId;
 
+import a8k.app.utils.MinRotationAngle;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
@@ -54,30 +56,70 @@ public class TurnableMoveCtrlService {
 		}
 	}
 
+	private int distanceInCircle(int pos0, int pos1, int cirucle) {
+		int distance = Math.abs((pos1 - pos0) % cirucle);
+		if (distance > cirucle / 2) {
+			distance = cirucle - distance;
+		}
+		return distance;
+	}
+
+	private int findNearPos(Integer now, Integer target) {
+		int t1;
+		int t2;
+		target = target % 36000;
+		if (target < 0) {
+			t1 = target;
+			t2 = target + 36000;
+		} else {
+			t1 = target - 36000;
+			t2 = target;
+		}
+
+		int d1 = Math.abs(now - t1);
+		int d2 = Math.abs(now - t2);
+
+		if (d1 < d2) {
+			return t1;
+		} else {
+			return t2;
+		}
+
+
+	}
+
 
 	private void trunableMoveTo(Integer pos) throws AppException {
 		checkBeforeMoveTrunable();
 		//限制pos在 0--> 36000之间
-		pos = pos % 36000;
-		if (pos < 0) {
-			pos += 36000;
-		}
+
+		int nowPos     = stepMotorCtrlDriver.stepMotorReadPos(StepMotorMId.IncubatorRotateCtrlM);
+		int dTargetPos = MinRotationAngle.minRotationAngle(nowPos, pos, 36000);
+		int targetPos  = dTargetPos + nowPos;
+
 
 		//先移动半个间距，用来检测是否发生卡板
-		Integer nowPos = stepMotorCtrlDriver.stepMotorReadPos(StepMotorMId.IncubatorRotateCtrlM);
-		if (nowPos < pos) {
+		if (nowPos < targetPos) {
 			stepMotorCtrlDriver.stepMotorEasyMoveByBlock(StepMotorMId.IncubatorRotateCtrlM, turntablePosParamMgr.getPosSpacing());
-		} else if (nowPos > pos) {
+		} else if (nowPos > targetPos) {
 			stepMotorCtrlDriver.stepMotorEasyMoveByBlock(StepMotorMId.IncubatorRotateCtrlM, -turntablePosParamMgr.getPosSpacing());
 		}
 
 		//解决齿轮间隙的问题
-		if (nowPos < pos) {
-			stepMotorCtrlDriver.stepMotorEasyMoveToBlock(StepMotorMId.IncubatorRotateCtrlM, pos);
+		if (nowPos < targetPos) {
+			stepMotorCtrlDriver.stepMotorEasyMoveToBlock(StepMotorMId.IncubatorRotateCtrlM, targetPos);
 		} else {
-			stepMotorCtrlDriver.stepMotorEasyMoveToBlock(StepMotorMId.IncubatorRotateCtrlM, pos - 300/**/);
-			stepMotorCtrlDriver.stepMotorEasyMoveToBlock(StepMotorMId.IncubatorRotateCtrlM, pos);
+			stepMotorCtrlDriver.stepMotorEasyMoveToBlock(StepMotorMId.IncubatorRotateCtrlM, targetPos - 300/**/);
+			stepMotorCtrlDriver.stepMotorEasyMoveToBlock(StepMotorMId.IncubatorRotateCtrlM, targetPos);
 		}
+
+
+		int afterRunNowPos = stepMotorCtrlDriver.stepMotorReadPos(StepMotorMId.IncubatorRotateCtrlM);
+		afterRunNowPos = afterRunNowPos % 36000;
+		if (afterRunNowPos < 0)
+			afterRunNowPos = afterRunNowPos + 36000;
+		stepMotorCtrlDriver.setCurrentPos(StepMotorMId.IncubatorRotateCtrlM, afterRunNowPos);
+
 	}
 
 	public void trunableMoveToPushPos(IncubatorPos index) throws AppException {

src/main/java/a8k/app/service/param/optparam/OptModuleExtParamsMgr.java

@@ -26,6 +26,7 @@ public class OptModuleExtParamsMgr extends ParamMgr {
 			initParam(pos, pos.chName, pos.type);
 		}
 
+
 		//校验参数类型
 		Arrays.stream(A8kOptType.values()).sequential().forEach(this::getOptScanStartPos);
 		Arrays.stream(A8kOptType.values()).sequential().forEach(this::getScanGain);

src/main/java/a8k/app/type/param/optpos/OptModuleExtParam.java

@@ -3,20 +3,23 @@ package a8k.app.type.param.optpos;
 public enum OptModuleExtParam {
 //	OptScanRefPos("光学扫描参考坐标", Integer.class),
 
-	FOptScanShift("F光学扫描偏移", Integer.class),
-	FOptEmissionIntensity("F发射强度", Integer.class),//Int
-	FOptScanGainVal("F光学扫描放大倍数", Double.class),//Double
+	FOptScanShift("F光学扫描偏移", Integer.class,2800),
+	FOptEmissionIntensity("F发射强度", Integer.class,1),//Int
+	FOptScanGainVal("F光学扫描放大倍数", Double.class,1),//Double
+
+	TOptScanShift("T光学扫描偏移", Integer.class,3508),
+	TOptEmissionIntensity("T发射强度", Integer.class,1),
+	TOptScanGainVal("T光学扫描放大倍数", Double.class,0),
 
-	TOptScanShift("T光学扫描偏移", Integer.class),
-	TOptEmissionIntensity("T发射强度", Integer.class),
-	TOptScanGainVal("T光学扫描放大倍数", Double.class),
 	;
 
 	public final String   chName;
 	public final Class<?> type;
+	public final Object defultValue;
 
-	OptModuleExtParam(String chName, Class<?> type) {
+	OptModuleExtParam(String chName, Class<?> type, Object defultValue) {
 		this.chName = chName;
 		this.type   = type;
+		this.defultValue = defultValue;
 	}
 }

src/main/java/a8k/app/utils/MinRotationAngle.java

@@ -0,0 +1,37 @@
+package a8k.app.utils;
+
+public class MinRotationAngle {
+
+    public static void main(String[] args) {
+        // 示例输入
+        int now = 350;
+        int target = -20;
+
+        // 输出最快转动角度
+        System.out.println(minRotationAngle(now,target,360));  // 输出 10
+    }
+
+    public static int minRotationAngle(int now,int target,int circleNum ) {
+        // 标准化位置，确保角度在 0 到 circleNum 之间
+        target = target % circleNum;
+        now = now % circleNum;
+
+        // 处理负数的情况，确保位置值在 0 到 circleNum 之间
+        if (target < 0) target += circleNum;
+        if (now < 0) now += circleNum;
+
+        // 计算顺时针和逆时针的差距
+        int clockwise = (target - now) % circleNum;
+        if (clockwise < 0) clockwise += circleNum;  // 确保差距为正值
+
+        int counterclockwise = (now - target) % circleNum;
+        if (counterclockwise < 0) counterclockwise += circleNum;  // 确保差距为正值
+
+        // 判断并返回带方向的最小转动角度
+        if (clockwise <= counterclockwise) {
+            return clockwise;  // 顺时针方向
+        } else {
+            return -counterclockwise;  // 逆时针方向，返回负值
+        }
+    }
+}

src/main/java/a8k/extui/page/driver/OptScannerCtrlPage.java

@@ -0,0 +1,104 @@
+package a8k.extui.page.driver;
+
+import a8k.app.hardware.driver.OptModuleDriver;
+import a8k.app.hardware.driver.StepMotorCtrlDriver;
+import a8k.app.hardware.type.StepMotorMId;
+import a8k.app.hardware.type.OptModuleRegIndex;
+import a8k.app.type.exception.AppException;
+import a8k.app.utils.ZJsonNode;
+import a8k.extui.mgr.ExtApiPageMgr;
+import jakarta.annotation.PostConstruct;
+import jakarta.annotation.Resource;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+
+@Component
+@Slf4j
+@RequiredArgsConstructor
+public class OptScannerCtrlPage {
+
+	final private OptModuleDriver optModuleDriver;
+
+
+	final private ExtApiPageMgr extApiPageMgr;
+
+	StepMotorMId id   = StepMotorMId.FeedingModXM;
+	Integer      dpos = 10;
+
+
+
+	public Object readAllRegs() throws AppException {
+		ZJsonNode node = new ZJsonNode();
+		for (OptModuleRegIndex reg : OptModuleRegIndex.values()) {
+			try {
+				Integer val = optModuleDriver.getReg(reg);
+				node.get(reg.name()).set(val);
+			} catch (AppException e) {
+				node.get(reg.name()).set(e.getError().code);
+			}
+
+		}
+		return node.get();
+	}
+
+	public void setReg(OptModuleRegIndex reg, Integer val) throws AppException {
+		optModuleDriver.setReg(reg, val);
+	}
+
+	public void setStartAndStopVel(Integer v) throws AppException {
+		optModuleDriver.setReg(OptModuleRegIndex.kreg_a8k_opt_scan_vstart, v);
+		optModuleDriver.setReg(OptModuleRegIndex.kreg_a8k_opt_scan_vstop, v);
+	}
+
+	public void setV1(Integer v) throws AppException {
+		optModuleDriver.setReg(OptModuleRegIndex.kreg_a8k_opt_scan_v1, v);
+	}
+
+	public void setA1AndD1(Integer acc) throws AppException {
+		optModuleDriver.setReg(OptModuleRegIndex.kreg_a8k_opt_scan_a1, acc);
+		optModuleDriver.setReg(OptModuleRegIndex.kreg_a8k_opt_scan_d1, acc);
+	}
+
+	public void setAmaxAndDmax(Integer acc) throws AppException {
+		optModuleDriver.setReg(OptModuleRegIndex.kreg_a8k_opt_scan_amax, acc);
+		optModuleDriver.setReg(OptModuleRegIndex.kreg_a8k_opt_scan_dmax, acc);
+	}
+
+	public void setDefaultVel(Integer v) throws AppException {
+		optModuleDriver.setReg(OptModuleRegIndex.kreg_a8k_opt_scan_vdefault, v);
+	}
+
+
+
+	public Integer readReg(OptModuleRegIndex reg) {
+		try {
+			return optModuleDriver.getReg(reg);
+		} catch (AppException e) {
+			return 0;
+		}
+	}
+
+
+	@PostConstruct
+	void init() {
+		var page = extApiPageMgr.newPage(this);
+		page.newGroup("寄存器配置");
+		page.addFunction("设置起停速度", this::setStartAndStopVel).setParamVal("v", () -> readReg(OptModuleRegIndex.kreg_a8k_opt_scan_vstart));
+		page.addFunction("设置V1", this::setV1).setParamVal("v", () -> readReg(OptModuleRegIndex.kreg_a8k_opt_scan_v1));
+		page.addFunction("设置加速度", this::setA1AndD1).setParamVal("acc", () -> readReg(OptModuleRegIndex.kreg_a8k_opt_scan_a1));
+		page.addFunction("设置最大加速度", this::setAmaxAndDmax).setParamVal("acc", () -> readReg(OptModuleRegIndex.kreg_a8k_opt_scan_amax));
+		page.addFunction("设置默认速度", this::setDefaultVel).setParamVal("v", () -> readReg(OptModuleRegIndex.kreg_a8k_opt_scan_vdefault));
+
+		page.addFunction("设置寄存器", this::setReg);
+		page.addFunction("读取所有寄存器", this::readAllRegs);
+
+
+
+		extApiPageMgr.addPage(page);
+
+
+	}
+}

src/main/resources/db/zapp_a8k_pos_parameter.csv

@@ -11,7 +11,7 @@ id,service,key,valType,val,chName
 25,TubeFeedingModuleParamMgr,Tube0PreProcessPos,Integer,"{""value"":1185}",01试管预处理位置
 26,TubeFeedingModuleParamMgr,TubeScanServoTorque,Integer,"{""value"":500}",试管扫描伺服力矩
 27,TubeFeedingModuleParamMgr,TubeSpacing,Double,"{""value"":200.22222222222223}",试管间距
-28,HbotFixedPosParamMgr,DropLiquidPos,Pos3d,"{""x"":24358,""y"":4100,""z"":1340}",滴液位置
+28,HbotFixedPosParamMgr,DropLiquidPos,Pos3d,"{""x"":24746,""y"":4306,""z"":1340}",滴液位置
 29,HbotSamplePosParamMgr,EmergencyTubeSamplePos,Pos3d,"{""x"":4857,""y"":3191,""z"":274}",<急诊位>取样位置
 30,HbotSamplePosParamMgr,EmergencyTubeSampleEndPos,Pos3d,"{""x"":4857,""y"":3191,""z"":490}",<急诊位>取样结束位置
 31,HbotSamplePosParamMgr,BloodHTubeSamplePos,Pos3d,"{""x"":2331,""y"":4017,""z"":294}",<全血高试管>取样位置

src/main/resources/db/zapp_sub_module_reg_initial_value.csv

@@ -1,6 +1,6 @@
 id,mid,regIndex,regInitVal
 1,HbotM,kreg_xyrobot_robot_type,0
-2,HbotM,kreg_xyrobot_one_circle_pulse,72000
+2,HbotM,kreg_xyrobot_one_circle_pulse,73000
 3,HbotM,kreg_xyrobot_one_circle_pulse_denominator,10
 4,HbotM,kreg_xyrobot_ihold,10
 5,HbotM,kreg_xyrobot_irun,31
@@ -169,7 +169,7 @@ id,mid,regIndex,regInitVal
 168,ShakeModGripperYSV,kreg_mini_servo_limit_torque,500
 169,ShakeModGripperYSV,kreg_mini_servo_protective_torque,800
 170,ShakeModGripperYSV,kreg_mini_servo_target_pos_tolerance,15
-171,ShakeModGripperSV,kreg_mini_servo_pos,1589
+171,ShakeModGripperSV,kreg_mini_servo_pos,1503
 172,ShakeModGripperSV,kreg_mini_servo_limit_velocity,10000
 173,ShakeModGripperSV,kreg_mini_servo_limit_torque,500
 174,ShakeModGripperSV,kreg_mini_servo_protective_torque,800
@@ -179,19 +179,16 @@ id,mid,regIndex,regInitVal
 178,ShakeModTubeScanerClampingSV,kreg_mini_servo_limit_torque,300
 179,ShakeModTubeScanerClampingSV,kreg_mini_servo_protective_torque,800
 180,ShakeModTubeScanerClampingSV,kreg_mini_servo_target_pos_tolerance,15
-181,ShakeModTubeScanerRotateSV,kreg_mini_servo_pos,2669
+181,ShakeModTubeScanerRotateSV,kreg_mini_servo_pos,2666
 182,ShakeModTubeScanerRotateSV,kreg_mini_servo_limit_velocity,10000
 183,ShakeModTubeScanerRotateSV,kreg_mini_servo_limit_torque,300
 184,ShakeModTubeScanerRotateSV,kreg_mini_servo_protective_torque,800
 185,ShakeModTubeScanerRotateSV,kreg_mini_servo_target_pos_tolerance,15
-186,ShakeModLiftingSV,kreg_mini_servo_pos,650
+186,ShakeModLiftingSV,kreg_mini_servo_pos,642
 187,ShakeModLiftingSV,kreg_mini_servo_limit_velocity,800
 188,ShakeModLiftingSV,kreg_mini_servo_limit_torque,100
 189,ShakeModLiftingSV,kreg_mini_servo_protective_torque,800
 190,ShakeModLiftingSV,kreg_mini_servo_target_pos_tolerance,30
-191,PlatesBoxTCM,kreg_water_cooling_tmp_controler_pid_target,250
-192,PlatesBoxTCM,kreg_water_cooling_tmp_controler_pid_nowoutput,0
-193,PlatesBoxTCM,kreg_water_cooling_tmp_controler_pid_feedbackval,240
 194,PlatesBoxTCM,kreg_water_cooling_tmp_controler_pid_kp,6000
 195,PlatesBoxTCM,kreg_water_cooling_tmp_controler_pid_ki,100
 196,PlatesBoxTCM,kreg_water_cooling_tmp_controler_pid_kd,0
@@ -202,7 +199,7 @@ id,mid,regIndex,regInitVal
 201,PlatesBoxTCM,kreg_water_cooling_tmp_controler_pid_compute_interval,9000
 202,IncubatorTCM,kreg_water_cooling_tmp_controler_pid_target,250
 203,IncubatorTCM,kreg_water_cooling_tmp_controler_pid_nowoutput,0
-204,IncubatorTCM,kreg_water_cooling_tmp_controler_pid_feedbackval,240
+204,IncubatorTCM,kreg_water_cooling_tmp_controler_pid_feedbackval,269
 205,IncubatorTCM,kreg_water_cooling_tmp_controler_pid_kp,6000
 206,IncubatorTCM,kreg_water_cooling_tmp_controler_pid_ki,100
 207,IncubatorTCM,kreg_water_cooling_tmp_controler_pid_kd,0
@@ -345,24 +342,24 @@ id,mid,regIndex,regInitVal
 350,OptModScannerM,kreg_step_motor_shaft,1
 351,OptModScannerM,kreg_step_motor_one_circle_pulse,1590000
 352,OptModScannerM,kreg_step_motor_one_circle_pulse_denominator,10000
-353,OptModScannerM,kreg_step_motor_default_velocity,600
+353,OptModScannerM,kreg_step_motor_default_velocity,1200
 354,OptModScannerM,kreg_step_motor_ihold,3
-355,OptModScannerM,kreg_step_motor_irun,15
+355,OptModScannerM,kreg_step_motor_irun,8
 356,OptModScannerM,kreg_step_motor_iholddelay,1000
 357,OptModScannerM,kreg_step_motor_iglobalscaler,0
-358,OptModScannerM,kreg_step_motor_mres,0
+358,OptModScannerM,kreg_step_motor_mres,2
 359,OptModScannerM,kreg_step_motor_run_to_zero_speed,600
 360,OptModScannerM,kreg_step_motor_look_zero_edge_speed,100
 361,OptModScannerM,kreg_step_motor_max_d,0
 362,OptModScannerM,kreg_step_motor_min_d,0
 363,OptModScannerM,kreg_step_motor_in_debug_mode,0
-364,OptModScannerM,kreg_step_motor_vstart,100
+364,OptModScannerM,kreg_step_motor_vstart,300
 365,OptModScannerM,kreg_step_motor_a1,50
-366,OptModScannerM,kreg_step_motor_amax,300
+366,OptModScannerM,kreg_step_motor_amax,500
 367,OptModScannerM,kreg_step_motor_v1,300
-368,OptModScannerM,kreg_step_motor_dmax,300
+368,OptModScannerM,kreg_step_motor_dmax,500
 369,OptModScannerM,kreg_step_motor_d1,50
-370,OptModScannerM,kreg_step_motor_vstop,100
+370,OptModScannerM,kreg_step_motor_vstop,300
 371,OptModScannerM,kreg_step_motor_tzerowait,0
 372,OptModScannerM,kreg_step_motor_enc_resolution,0
 373,OptModScannerM,kreg_step_motor_enable_enc,0
@@ -396,20 +393,20 @@ id,mid,regIndex,regInitVal
 401,OptModPullM,kreg_step_motor_dzero_pos,0
 402,OptModPullM,kret_step_motor_pos_devi_tolerance,30
 403,OptModPullM,kret_step_motor_io_trigger_append_distance,10
-404,OptMod,kreg_a8k_opt_t_pos_offset,3723
-405,OptMod,kreg_a8k_opt_f_pos_offset,2559
-406,OptMod,kreg_a8k_opt_t_reverse_scan_pos_offset,2523
-407,OptMod,kreg_a8k_opt_f_reverse_scan_pos_offset,1359
+404,OptMod,kreg_a8k_opt_t_pos_offset,3508
+405,OptMod,kreg_a8k_opt_f_pos_offset,2800
+406,OptMod,kreg_a8k_opt_t_reverse_scan_pos_offset,2308
+407,OptMod,kreg_a8k_opt_f_reverse_scan_pos_offset,1600
 408,OptMod,kreg_a8k_opt_scan_step_interval,1
 409,OptMod,kreg_a8k_opt_scan_pointnum,1200
-410,OptMod,kreg_a8k_opt_scan_vdefault,1200
-411,OptMod,kreg_a8k_opt_scan_vstart,400
-412,OptMod,kreg_a8k_opt_scan_a1,300
-413,OptMod,kreg_a8k_opt_scan_amax,1000
-414,OptMod,kreg_a8k_opt_scan_v1,550
-415,OptMod,kreg_a8k_opt_scan_dmax,1000
-416,OptMod,kreg_a8k_opt_scan_d1,300
-417,OptMod,kreg_a8k_opt_scan_vstop,400
+410,OptMod,kreg_a8k_opt_scan_vdefault,1800
+411,OptMod,kreg_a8k_opt_scan_vstart,700
+412,OptMod,kreg_a8k_opt_scan_a1,700
+413,OptMod,kreg_a8k_opt_scan_amax,700
+414,OptMod,kreg_a8k_opt_scan_v1,700
+415,OptMod,kreg_a8k_opt_scan_dmax,700
+416,OptMod,kreg_a8k_opt_scan_d1,700
+417,OptMod,kreg_a8k_opt_scan_vstop,700
 418,OptMod,kreg_a8k_opt_scan_tzerowait,0
 419,PipetteMod,kreg_pipette_zm_pos_devi_tolerance,0
 420,PipetteMod,kreg_pipette_zm_io_trigger_append_distance,0