update

src/main/java/a8k/a8k_can_protocol/MId.java

@@ -0,0 +1,120 @@
+package a8k.a8k_can_protocol;
+
+public enum MId {
+	NotSet(0, "未设置"),//
+	HbotBoard(10, "机械臂板模块"),//
+	HbotM(11, "机械臂XY"),//
+	//
+	PlatesBoxBoard(20, "板夹仓模块"),//
+	PlatesBoxYM(21, "板夹仓移动电机"),//
+	PlatesBoxPusherM(22, "板夹仓推杆电机"),//
+	PlatesBoxScanner(23, "板夹仓扫码模组"),//
+	//
+	ShakeModBoard(30, "摇匀模组板"),//
+	ShakeModClampingM(31, "试管固定夹爪电机"),//
+	ShakeModGripperZM(32, "摇匀升降电机"),//
+	ShakeModShakeM(33, "试管摇匀电机"),//
+	ShakeModGripperYM(34, "摇匀前后电机"),//
+	ShakeModGripperSV(35, "摇匀试管帽夹爪"),//
+	ShakeModTubeScanerClampingSV(36, "试管架旋转固定舵机"),//
+	ShakeModTubeScanerRotateSV(37, "试管架旋转舵机"),//
+	//
+	PlatesBoxTCMBoard(40, "反应板夹温度控制板"),//
+	PlatesBoxTCM(41, "反应板夹温度控制模块"),//
+	WbTubeFanMod(42, "气溶胶风扇"),//
+	//
+	IncubatorTCMBoard(50, "温度控制"),//
+	IncubatorTCM(51, "温度控制"),//
+	//
+	FeedingModBoard(60, "出入料模块"),//
+	FeedingModInfeedM(61, "入料电机"),//
+	FeedingModXM(62, "试管架平移电机"),//
+	FeedingModOutfeedM(63, "出料电机"),//
+	FeedingModScannerMod(64, "试管架扫码器"),//
+	//
+	IncubatorRotateBoard(70, "孵育盘旋转板"),//
+	IncubatorRotateCtrlM(71, "孵育盘旋转"),//
+	//
+	PipetteModBoard(80, "机械臂Z轴板"),//
+	PipetteModZM(81, "机械臂Z"),//
+	PipetteMod(82, "移液枪"),//
+	PipetteModCodeScanner(83, "物料扫码器"),//
+	//
+	OptModBoard(90, "光学模组板"),//
+	OptModScannerM(91, "板卡扫描电机"),//
+	OptModPullM(92, "板卡推杆电机"),//
+	OptMod(93, "扫描仪"),//
+	//
+	A8kIdCardReaderBoard(100, "A8K读卡器板"),//
+	A8kIdCardReader(101, "A8K读卡器"),//
+	;
+
+
+	final public String chname;
+	final public int    index;
+
+	MId(int index, String chname) {
+		this.chname = chname;
+		this.index  = index;
+	}
+
+	public int toInt() {
+		return index;
+	}
+
+	public static MId valueOf(Integer val) {
+		return valueOf(val.intValue());
+	}
+
+	public static MId valueOf(int val) {
+		return switch (val) {
+			case 0 -> NotSet;
+			case 10 -> HbotBoard;
+			case 11 -> HbotM;
+			//
+			case 20 -> PlatesBoxBoard;
+			case 21 -> PlatesBoxYM;
+			case 22 -> PlatesBoxPusherM;
+			case 23 -> PlatesBoxScanner;
+			//
+			case 30 -> ShakeModBoard;
+			case 31 -> ShakeModClampingM;
+			case 32 -> ShakeModGripperZM;
+			case 33 -> ShakeModShakeM;
+			case 34 -> ShakeModGripperYM;
+			case 35 -> ShakeModGripperSV;
+			case 36 -> ShakeModTubeScanerClampingSV;
+			case 37 -> ShakeModTubeScanerRotateSV;
+			//
+			case 40 -> PlatesBoxTCMBoard;
+			case 41 -> PlatesBoxTCM;
+			case 42 -> WbTubeFanMod;
+			//
+			case 50 -> IncubatorTCMBoard;
+			case 51 -> IncubatorTCM;
+			//
+			case 60 -> FeedingModBoard;
+			case 61 -> FeedingModInfeedM;
+			case 62 -> FeedingModXM;
+			case 63 -> FeedingModOutfeedM;
+			case 64 -> FeedingModScannerMod;
+			//
+			case 70 -> IncubatorRotateBoard;
+			case 71 -> IncubatorRotateCtrlM;
+			//
+			case 80 -> PipetteModBoard;
+			case 81 -> PipetteModZM;
+			case 82 -> PipetteMod;
+			case 83 -> PipetteModCodeScanner;
+			//
+			case 90 -> OptModBoard;
+			case 91 -> OptModScannerM;
+			case 92 -> OptModPullM;
+			case 93 -> OptMod;
+			//
+			case 100 -> A8kIdCardReaderBoard;
+			case 101 -> A8kIdCardReader;
+			default -> NotSet;
+		};
+	}
+}

src/main/java/a8k/appbean/AppErrorCode.java

@@ -7,24 +7,21 @@ public enum AppErrorCode {
 	LargeBufferNotEnough("大瓶缓冲液不足", 3), //
 	PasswdError("密码错误", 4), //
 	UserDoesNotExist("用户不存在", 5), //
-	GripperPosError("抓手舵机位置异常", 6), //
-	GripperLiftMotorPosError("抓手升降电机位置异常", 8), //
-	GripperHorizontalMovementMotorPosError("抓手前后移动舵机位置异常", 9),//
+	GripperMPosError("抓手舵机位置异常", 6), //
+	GripperZMPosError("抓手升降电机位置异常", 8), //
+	GripperYMPosError("抓手前后移动舵机位置异常", 9),//
 	TubesInShakeModule("摇匀模组位置有试管", 10),//
+	PlateStuckDetectorSensorTrigger("卡板检查光电触发", 11),//
 	;
 
-
 	final private String chName;
 	final private int    errorIndex;
 
-	public int mid;
-
 	private AppErrorCode(String chname, int errorIndex) {
 		this.chName     = chname;
 		this.errorIndex = errorIndex;
 	}
 
-
 	public String getChName() {
 		return chName;
 	}

src/main/java/a8k/appbean/ecode/AppEcode.java

@@ -0,0 +1,29 @@
+package a8k.appbean.ecode;
+
+import a8k.a8k_can_protocol.MId;
+import a8k.appbean.AppErrorCode;
+
+public class AppEcode {
+	AppErrorCode errorCode;
+	MId          mid;
+
+
+	public AppEcode(AppErrorCode errorCode, MId mid) {
+		this.errorCode = errorCode;
+		this.mid       = mid;
+	}
+
+	public AppEcode(AppErrorCode errorCode) {
+		this.errorCode = errorCode;
+		this.mid       = MId.NotSet;
+	}
+
+	public boolean isOk() {
+		return errorCode == AppErrorCode.Success;
+	}
+
+	public MId getMid() {
+		return mid;
+	}
+
+}

src/main/java/a8k/base_hardware/A8kCanBusService.java

@@ -1,6 +1,7 @@
 package a8k.base_hardware;
 
 import a8k.a8k_can_protocol.*;
+import a8k.a8k_can_protocol.MId;
 import a8k.appbean.HardwareException;
 import a8k.appbean.appevent.A8kHardwareReport;
 import a8k.service.AppEventBusService;
@@ -64,7 +65,7 @@ public class A8kCanBusService {
 	int packetIndex = 0;//
 
 	// 调试标志位
-	boolean debugFlag        = false;//
+	boolean debugFlag        = true;//
 	// websocket自动重连时间
 	Timer   autoConnectTimer = new Timer();//
 
@@ -140,139 +141,139 @@ public class A8kCanBusService {
 	//
 	// module opeation
 	//
-	public void modulePing(int id) throws HardwareException {
-		callcmd(id, CmdId.kmodule_ping);
+	public void modulePing(MId id) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kmodule_ping);
 	}
 
-	public void moduleStop(int id) throws HardwareException {
-		callcmd(id, CmdId.kmodule_stop);
+	public void moduleStop(MId id) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kmodule_stop);
 	}
 
-	public ModuleStatus getModuleStatus(int id) throws HardwareException {
-		var packet = callcmd(id, CmdId.kmodule_get_status);
+	public ModuleStatus getModuleStatus(MId id) throws HardwareException {
+		var packet = callcmd(id.toInt(), CmdId.kmodule_get_status);
 		return ModuleStatus.valueOf(packet.getContentI32(0));
 
 	}
 
-	public void moduleSetReg(int id, RegIndex regindex, int reg) throws HardwareException {
-		callcmd(id, CmdId.kmodule_set_reg, regindex.ordinal(), reg);
+	public void moduleSetReg(MId id, RegIndex regindex, int reg) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kmodule_set_reg, regindex.ordinal(), reg);
 	}
 
-	public int moduleGetReg(int id, RegIndex regindex) throws HardwareException {
-		var packet = callcmd(id, CmdId.kmodule_get_reg, regindex.ordinal());
+	public int moduleGetReg(MId id, RegIndex regindex) throws HardwareException {
+		var packet = callcmd(id.toInt(), CmdId.kmodule_get_reg, regindex.ordinal());
 		return packet.getContentI32(0);
 	}
 
-	public int moduleGetError(int id) throws HardwareException {
-		var packet = callcmd(id, CmdId.kmodule_get_error);
+	public int moduleGetError(MId id) throws HardwareException {
+		var packet = callcmd(id.toInt(), CmdId.kmodule_get_error);
 		return packet.getContentI32(0);
 	}
 
-	public void moduleClearError(int id) throws HardwareException {
-		callcmd(id, CmdId.kmodule_clear_error);
+	public void moduleClearError(MId id) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kmodule_clear_error);
 	}
 
-	public void moduleActiveCfg(int id) throws HardwareException {
-		callcmd(id, CmdId.kmodule_active_cfg);
+	public void moduleActiveCfg(MId id) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kmodule_active_cfg);
 	}
 
 	//
 	// stepMotor
 	//
-	public void stepMotorEnable(int mid, int enable) throws HardwareException {
-		callcmd(mid, CmdId.kstep_motor_enable, enable);
+	public void stepMotorEnable(MId mid, int enable) throws HardwareException {
+		callcmd(mid.toInt(), CmdId.kstep_motor_enable, enable);
 	}
 
-	public int stepMotorReadPos(int id) throws HardwareException {
-		A8kPacket packet = callcmd(id, CmdId.kstep_motor_read_pos);
+	public int stepMotorReadPos(MId id) throws HardwareException {
+		A8kPacket packet = callcmd(id.toInt(), CmdId.kstep_motor_read_pos);
 		return packet.getContentI32(0);
 	}
 
-	public void stepMotorEasyRotate(int id, int direction) throws HardwareException {
-		callcmd(id, CmdId.kstep_motor_easy_rotate, direction);
+	public void stepMotorEasyRotate(MId id, int direction) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kstep_motor_easy_rotate, direction);
 	}
 
-	public void stepMotorEasyMoveBy(int id, int dpos) throws HardwareException {
-		callcmd(id, CmdId.kstep_motor_easy_move_by, dpos);
+	public void stepMotorEasyMoveBy(MId id, int dpos) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kstep_motor_easy_move_by, dpos);
 	}
 
-	public void stepMotorEasyMoveTo(int id, int pos) throws HardwareException {
-		callcmd(id, CmdId.kstep_motor_easy_move_to, pos);
+	public void stepMotorEasyMoveTo(MId id, int pos) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kstep_motor_easy_move_to, pos);
 	}
 
-	public void stepMotorEasyMoveToZero(int id) throws HardwareException {
-		callcmd(id, CmdId.kstep_motor_easy_move_to_zero);
+	public void stepMotorEasyMoveToZero(MId id) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kstep_motor_easy_move_to_zero);
 	}
 
-	public void stepMotorEasySetCurrentPos(int id, int pos) throws HardwareException {
-		callcmd(id, CmdId.kstep_motor_easy_set_current_pos, pos);
+	public void stepMotorEasySetCurrentPos(MId id, int pos) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kstep_motor_easy_set_current_pos, pos);
 	}
 
-	public void stepMotorEasyMoveToIo(int id, int io) throws HardwareException {
-		callcmd(id, CmdId.kstep_motor_easy_move_to_io, io);
+	public void stepMotorEasyMoveToIo(MId id, int io) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kstep_motor_easy_move_to_io, io);
 	}
 
-	public void stepMotorStop(int id) throws HardwareException {
-		callcmd(id, CmdId.kstep_motor_stop);
+	public void stepMotorStop(MId id) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kstep_motor_stop);
 	}
 
-	public void stepMotorActiveCfg(int id) throws HardwareException {
-		callcmd(id, CmdId.kstep_motor_active_cfg);
+	public void stepMotorActiveCfg(MId id) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kstep_motor_active_cfg);
 	}
 
-	public int stepMotorReadIoState(int id) throws HardwareException {
-		var packet = callcmd(id, CmdId.kstep_motor_read_io_state);
+	public int stepMotorReadIoState(MId id) throws HardwareException {
+		var packet = callcmd(id.toInt(), CmdId.kstep_motor_read_io_state);
 		return packet.getContentI32(0);
 	}
 
-	public void stepMotorEasyMoveToEndPoint(int id) throws HardwareException {
-		callcmd(id, CmdId.kstep_motor_easy_move_to_end_point);
+	public void stepMotorEasyMoveToEndPoint(MId id) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kstep_motor_easy_move_to_end_point);
 	}
 
-	public void stepMotorEasyReciprocatingMotion(int id, int startpos, int endpos, int times) throws HardwareException {
-		callcmd(id, CmdId.kstep_motor_easy_reciprocating_motion, startpos, endpos, times);
+	public void stepMotorEasyReciprocatingMotion(MId id, int startpos, int endpos, int times) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kstep_motor_easy_reciprocating_motion, startpos, endpos, times);
 	}
 
 	//
 	// MINI_SERVO
 	//
 
-	public void miniServoEnable(int id, int enable) throws HardwareException {
-		callcmd(id, CmdId.kmini_servo_enable, enable);
+	public void miniServoEnable(MId id, int enable) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kmini_servo_enable, enable);
 	}
 
-	public int miniServoReadPos(int id) throws HardwareException {
-		var packet = callcmd(id, CmdId.kmini_servo_read_pos);
+	public int miniServoReadPos(MId id) throws HardwareException {
+		var packet = callcmd(id.toInt(), CmdId.kmini_servo_read_pos);
 		return packet.getContentI32(0);
 	}
 
-	public void miniServoActiveCfg(int id) throws HardwareException {
-		callcmd(id, CmdId.kmini_servo_active_cfg);
+	public void miniServoActiveCfg(MId id) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kmini_servo_active_cfg);
 	}
 
-	public void miniServoStop(int id) throws HardwareException {
-		callcmd(id, CmdId.kmini_servo_stop);
+	public void miniServoStop(MId id) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kmini_servo_stop);
 	}
 
-	public void miniServoSetMidPoint(int id) throws HardwareException {
-		callcmd(id, CmdId.kmini_servo_set_mid_point);
+	public void miniServoSetMidPoint(MId id) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kmini_servo_set_mid_point);
 	}
 
-	public int miniServoReadIoState(int id) throws HardwareException {
-		var packet = callcmd(id, CmdId.kmini_servo_read_io_state);
+	public int miniServoReadIoState(MId id) throws HardwareException {
+		var packet = callcmd(id.toInt(), CmdId.kmini_servo_read_io_state);
 		return packet.getContentI32(0);
 	}
 
-	public void miniServoMoveTo(int id, int pos) throws HardwareException {
-		callcmd(id, CmdId.kmini_servo_move_to, pos);
+	public void miniServoMoveTo(MId id, int pos) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kmini_servo_move_to, pos);
 	}
 
-	public void miniServoRotate(int id, int direction) throws HardwareException {
-		callcmd(id, CmdId.kmini_servo_rotate, direction);
+	public void miniServoRotate(MId id, int direction) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kmini_servo_rotate, direction);
 	}
 
-	public void miniServoRotateWithTorque(int id, int torque) throws HardwareException {
-		callcmd(id, CmdId.kmini_servo_rotate_with_torque, torque);
+	public void miniServoRotateWithTorque(MId id, int torque) throws HardwareException {
+		callcmd(id.toInt(), CmdId.kmini_servo_rotate_with_torque, torque);
 	}
 
 	public boolean getIOState(IOId ioid) throws HardwareException {
@@ -295,21 +296,21 @@ public class A8kCanBusService {
 		}
 	}
 
-	public void waitForMod(Integer moduleId, Integer acitionOvertime) throws InterruptedException, HardwareException {
+	public void waitForMod(MId mid, Integer acitionOvertime) throws InterruptedException, HardwareException {
 		long startedAt = System.currentTimeMillis();
 		do {
 			try {
-				var status = getModuleStatus(moduleId);
+				var status = getModuleStatus(mid);
 				if (status == ModuleStatus.IDLE) {
 					break;
 				} else if (status == ModuleStatus.ERROR) {
-					throw new HardwareException(moduleId, moduleGetError(moduleId));
+					throw new HardwareException(mid.toInt(), moduleGetError(mid));
 				}
 			} catch (HardwareException ignored) {
 			}
 			long now = System.currentTimeMillis();
 			if (now - startedAt > acitionOvertime) {
-				throw new HardwareException(moduleId, Errorcode.kovertime);
+				throw new HardwareException(mid.toInt(), Errorcode.kovertime);
 			}
 
 			Thread.sleep(100);

src/main/java/a8k/service/ctrl_service/DeviceInitializationCtrlService.java

@@ -1,8 +1,10 @@
 package a8k.service.ctrl_service;
 
-import a8k.a8k_can_protocol.ModId;
+import a8k.a8k_can_protocol.IOId;
+import a8k.a8k_can_protocol.MId;
 import a8k.appbean.AppErrorCode;
 import a8k.appbean.HardwareException;
+import a8k.appbean.ecode.AppEcode;
 import a8k.base_hardware.A8kCanBusService;
 import a8k.service.db.dao.SamplesPreProcessModuleCtrlParamsService;
 import jakarta.annotation.Resource;
@@ -24,7 +26,6 @@ public class DeviceInitializationCtrlService {
 	 * 				2.试管夹紧
 	 *				3.抓手平移
 	 * 				4.抓手
-	 * 		0.
 	 * 		1. 抓手尝试移动到夹紧位置,等待一定时间，如果没有移动到夹紧位置，则返回错误。
 	 *		2. 试管夹紧电机归零，超时一定时间，没有归零，则返回错误。
 	 * 		3. 抓手平移电机，移动到待机位，如果移动不到，则返回错误。
@@ -61,68 +62,70 @@ public class DeviceInitializationCtrlService {
 	SamplesPreProcessModuleCtrlParamsService samplesPreProcessModuleCtrlParams;
 
 
-	private void hardwareStaticInit() throws HardwareException {
+	private AppErrorCode hardwareStaticInit() throws HardwareException {
 		/*
-		 *	复位思路
 		 * 		硬件初始化:
 		 * 			1.使能所有舵机
 		 *			2.打开必要的电源
 		 * 			3.使能所有电机
 		 */
 
-		//		HbotM
-		//PlatesBoxYM
-		//ShakeModClampingM
-		//ShakeModGripperZM
-		//ShakeModShakeM
-		//ShakeModGripperYM
-		//FeedingModInfeedM
-		//FeedingModXM
-		//FeedingModOutfeedM
-		//PipetteModZM
-		//OptModPullM
-
+		//使能所有电机
+		canBus.stepMotorEnable(MId.HbotM, 1);
+		canBus.stepMotorEnable(MId.PlatesBoxYM, 1);
+		canBus.stepMotorEnable(MId.ShakeModClampingM, 1);
+		canBus.stepMotorEnable(MId.ShakeModGripperZM, 1);
+		canBus.stepMotorEnable(MId.ShakeModShakeM, 1);
+		canBus.stepMotorEnable(MId.ShakeModGripperYM, 1);
+		canBus.stepMotorEnable(MId.FeedingModInfeedM, 1);
+		canBus.stepMotorEnable(MId.FeedingModXM, 1);
+		canBus.stepMotorEnable(MId.FeedingModOutfeedM, 1);
+		canBus.stepMotorEnable(MId.PipetteModZM, 1);
+		canBus.stepMotorEnable(MId.OptModPullM, 1);
+
+		//使能所有舵机
+		canBus.miniServoEnable(MId.ShakeModGripperSV, 1);
+		canBus.miniServoEnable(MId.ShakeModTubeScanerClampingSV, 1);
+		canBus.miniServoEnable(MId.ShakeModTubeScanerRotateSV, 1);
+
+		//打开必要的电源
+		canBus.setIOState(IOId.RecycleBinOverflowPPSPowerCtrl, true);
+		return AppErrorCode.Success;
+	}
 
-		canBus.stepMotorEnable(ModId.HbotM,1);
+	private AppEcode checkDeviceState() throws HardwareException {
+		/*
+		 * 	初始化前检查:
+		 * 		1. 试管平移通道是否有障碍
+		 * 		2. 板夹仓盖子是否盖上
+		 *		3. 板夹推杆是否在原点
+		 * 		4. 板夹拉取是否在终点或者原点
+		 */
 
-		//	public static final int ShakeModGripperSV            = 35;//摇匀试管帽夹爪
-		//	public static final int ShakeModTubeScanerClampingSV = 36;//试管架旋转固定舵机
-		//	public static final int ShakeModTubeScanerRotateSV   = 37;//试管架旋转舵机
+		//试管平移通道是否有障碍
+		boolean var = canBus.getIOState(IOId.THChInterPPS);
+		if (var)
+			return new AppEcode(AppErrorCode.PlateStuckDetectorSensorTrigger);
 
 
+		return new AppEcode(AppErrorCode.Success);
 
 	}
 
+
 	public AppErrorCode initializeDevice() {
 		logger.info("Initializing device ...");
 		try {
 			/*
 			 *	复位思路
 			 * 		硬件初始化:
-			 * 			1.使能所有舵机
-			 *			2.打开必要的电源
-			 * 			3.使能所有电机
-			 *
 			 *		检查
-			 * 			1.试管平移通道是否有障碍
-			 * 			2.板夹仓盖子是否盖上
-			 * 			3.推杆卡板光电是否触发
-			 * 			4.拉杆卡板光电是否触发
-			 * 			5.回收站光电是否被触发
-			 *
-			 *
 			 * 		复位
-			 * 			1.
-			 *
-			 *
-			 * 		清空设备
-			 *
-			 *
-			 *
+			 * 		清空耗材
 			 */
 
-			canBus.stepMotorEasyMoveToZero(ModId.ShakeModGripperZM);
-			canBus.waitForMod(ModId.ShakeModGripperZM, actionOvertime);
+			canBus.stepMotorEasyMoveToZero(MId.ShakeModGripperZM);
+			canBus.waitForMod(MId.ShakeModGripperZM, actionOvertime);
 		} catch (HardwareException e) {
 			logger.error("HardwareException");
 			throw new RuntimeException(e);