update

src/main/java/a8k/controler/api/v1/ApiV1ControllerAdvice.java

@@ -1,6 +1,6 @@
 package a8k.controler.api.v1;
 
-import a8k.type.appret.ApiV1Ret;
+import a8k.type.appret.ApiRet;
 import a8k.type.ecode.AppError;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -15,8 +15,8 @@ public class ApiV1ControllerAdvice {
 
 	@ResponseBody
 	@ExceptionHandler(value = Exception.class)
-	public ApiV1Ret<AppError> controllerExceptionHandler(Exception e) {
+	public ApiRet<?> controllerExceptionHandler(Exception e) {
 		logger.info("捕获到异常 : ", e);
-		return ApiV1Ret.fail(e);
+		return ApiRet.fail(e);
 	}
 }

src/main/java/a8k/controler/api/v1/app/assistant/ApiRetTestControler.java

@@ -3,7 +3,7 @@ package a8k.controler.api.v1.app.assistant;
 import a8k.hardware.type.a8kcanprotocol.A8kEcode;
 import a8k.hardware.type.a8kcanprotocol.CmdId;
 import a8k.hardware.type.a8kcanprotocol.MId;
-import a8k.type.appret.ApiV1Ret;
+import a8k.type.appret.ApiRet;
 import a8k.type.ecode.*;
 import a8k.type.exception.AppException;
 import io.swagger.v3.oas.annotations.Operation;
@@ -23,48 +23,28 @@ public class ApiRetTestControler {
 
 	@Operation(description = "获取成功返回值")
 	@PostMapping("getSuccessRet")
-	public ApiV1Ret<?> getSuccessRet() {
-		return ApiV1Ret.success();
+	public ApiRet<?> getSuccessRet() {
+		return ApiRet.success();
 	}
-
 	@Operation(description = "获取硬件错误返回值,此类错误为底层发生的硬件错误")
 	@PostMapping("getHardwareError")
-	public ApiV1Ret<AEHardwareError> getAppHardwareError() {
-		return ApiV1Ret.fail(//
-				new AEHardwareError(A8kEcode.LOW_ERROR_DEVICE_IS_BUSY, MId.PipetteMod, CmdId.a8k_opt_v2_f_close_laster));
+	public ApiRet<?> getAppHardwareError() throws AppException {
+		throw new AppException(new AEHardwareError(A8kEcode.APPE_PUT_TIP_FAIL, MId.PipetteMod, CmdId.a8k_opt_v2_f_close_laster));
 	}
-
 	@Operation(description = "获取代码错误返回值,此类错误为代码逻辑错误")
 	@PostMapping("getAppCodeError")
-	public ApiV1Ret<AECodeError> getAppCodeError() {
-		return ApiV1Ret.fail(//
-				new AECodeError("代码错误，这里显示的是提示信息")
-		);
+	public ApiRet<AECodeError> getAppCodeError() throws AppException {
+		throw new AppException(new AECodeError("代码错误"));
 	}
-
-
 	@Operation(description = "获取消耗不足错误返回值,此类错误需要前端提示用户缺少了哪个项目的耗材")
 	@PostMapping("getConsumeNotEnoughError")
-	public ApiV1Ret<AEConsumeNotEnoughError> getConsumeNotEnoughError() {
-		return ApiV1Ret.fail(//
-				new AEConsumeNotEnoughError("hscrp(项目名称)")
-		);
+	public ApiRet<?> getConsumeNotEnoughError() throws AppException {
+		throw new AppException(new AEConsumeNotEnoughError("hscrp(项目名称)"));
 	}
-
 	@Operation(description = "获取试管错误，此错误发生在试管处理过程中（扫描，脱帽，盖帽，摇匀），此错误，需要提示用户，是第几个试管发生了错误")
 	@PostMapping("getTubeError")
-	public ApiV1Ret<AETubeError> getTubeError() {
-		try {
+	public ApiRet<?> getTubeError() throws AppException {
 		throw new AppException(A8kEcode.APPE_A8K_PROJ_INFO_IS_ERROR);
-		} catch (AppException e) {
-			log.error("",e);
-		}
-
-		return ApiV1Ret.fail(//
-				new AETubeError(A8kEcode.APPE_A8K_PROJ_UNSUPPORTED, 6)
-		);
-
-
 	}
 
 }

src/main/java/a8k/controler/api/v1/app/basic/AppEventBusControler.java

@@ -2,7 +2,7 @@ package a8k.controler.api.v1.app.basic;
 
 import a8k.service.bases.FrontEndEventRouter;
 import a8k.service.bases.appevent.AppEvent;
-import a8k.type.appret.ApiV1Ret;
+import a8k.type.appret.ApiRet;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.annotation.Resource;
@@ -26,13 +26,13 @@ public class AppEventBusControler {
 
 	@Operation(summary = "获取一个事件")
 	@PostMapping("/pollAppEvent")
-	public ApiV1Ret<AppEvent> pollAppEvent() {
-		return ApiV1Ret.success(frontEndEventRouter.pollAppEvent());
+	public ApiRet<AppEvent> pollAppEvent() {
+		return ApiRet.success(frontEndEventRouter.pollAppEvent());
 	}
 
 	@Operation(summary = "获取全部事件")
 	@PostMapping("/pollAllAppEvents")
-	public ApiV1Ret<List<AppEvent>> pollAllAppEvents() {
-		return ApiV1Ret.success(frontEndEventRouter.pollAllAppEvents());
+	public ApiRet<List<AppEvent>> pollAllAppEvents() {
+		return ApiRet.success(frontEndEventRouter.pollAllAppEvents());
 	}
 }

src/main/java/a8k/controler/api/v1/app/ctrl/ConsumableScanControler.java

@@ -5,7 +5,7 @@ import a8k.service.app.appstate.statemgr.ConsumablesMgrService;
 import a8k.type.ConsumableGroup;
 import a8k.type.ConsumablesOneChannelScanResultPacket;
 import a8k.type.ConsumablesScanResultPacket;
-import a8k.type.appret.ApiV1Ret;
+import a8k.type.appret.ApiRet;
 import a8k.type.exception.AppException;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -32,16 +32,16 @@ public class ConsumableScanControler {
 	 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 	@Operation(summary = "扫描耗材(阻塞接口，耗时大概30多秒)")
 	@PostMapping("/scanConsumables")
-	public ApiV1Ret<ConsumablesScanResultPacket> scanConsumables() throws AppException {
+	public ApiRet<ConsumablesScanResultPacket> scanConsumables() throws AppException {
 		log.info("扫描耗材");
-		return ApiV1Ret.success(appConsumablesScanService.scanConsumables());
+		return ApiRet.success(appConsumablesScanService.scanConsumables());
 	}
 
 	@Operation(summary = "扫描某一组耗材(阻塞接口，耗时大概5秒)")
 	@PostMapping("/scanOneGroupConsumables")
-	public ApiV1Ret<ConsumablesOneChannelScanResultPacket> scanOneGroupConsumables(ConsumableGroup group) throws AppException {
+	public ApiRet<ConsumablesOneChannelScanResultPacket> scanOneGroupConsumables(ConsumableGroup group) throws AppException {
 		log.info("扫描某一组耗材");
-		return ApiV1Ret.success(appConsumablesScanService.scanOneGroupConsumables(group));
+		return ApiRet.success(appConsumablesScanService.scanOneGroupConsumables(group));
 	}
 
 }

src/main/java/a8k/controler/api/v1/app/ctrl/DeviceCtrlControler.java

@@ -1,7 +1,7 @@
 package a8k.controler.api.v1.app.ctrl;
 
 import a8k.service.app.appctrl.AppDeviceCtrlService;
-import a8k.type.appret.ApiV1Ret;
+import a8k.type.appret.ApiRet;
 import a8k.type.exception.AppException;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -31,30 +31,30 @@ public class DeviceCtrlControler {
 	 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 	@Operation(description = "开始工作")
 	@PostMapping("/startWork")
-	public ApiV1Ret<Void> startWork() throws AppException {
+	public ApiRet<Void> startWork() throws AppException {
 		appDeviceCtrlService.startWork();
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 	@Operation(description = "停止工作")
 	@PostMapping("/stopWork")
-	public ApiV1Ret<Void> stopWork() throws AppException {
+	public ApiRet<Void> stopWork() throws AppException {
 		appDeviceCtrlService.stopWork();
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 	@Operation(description = "暂停工作")
 	@PostMapping("/pauseWork")
-	public ApiV1Ret<Void> pauseWork() throws AppException {
+	public ApiRet<Void> pauseWork() throws AppException {
 		appDeviceCtrlService.pauseWork();
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 	@Operation(description = "继续工作")
 	@PostMapping("/continueWork")
-	public ApiV1Ret<Void> continueWork() throws AppException {
+	public ApiRet<Void> continueWork() throws AppException {
 		appDeviceCtrlService.continueWork();
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 }

src/main/java/a8k/controler/api/v1/app/ctrl/DeviceInit.java

@@ -1,7 +1,7 @@
 package a8k.controler.api.v1.app.ctrl;
 
 import a8k.service.app.appctrl.AppDeviceCtrlService;
-import a8k.type.appret.ApiV1Ret;
+import a8k.type.appret.ApiRet;
 import a8k.type.checkpoint.CheckResult;
 import a8k.type.exception.AppException;
 import io.swagger.v3.oas.annotations.Operation;
@@ -27,14 +27,14 @@ public class DeviceInit {
 
 	@Operation(description = "初始化设备")
 	@PostMapping("/initDevice")
-	public ApiV1Ret<List<CheckResult>> initDevice() throws AppException {
-		return ApiV1Ret.success(appDeviceCtrlService.initDevice());
+	public ApiRet<List<CheckResult>> initDevice() throws AppException {
+		return ApiRet.success(appDeviceCtrlService.initDevice());
 	}
 
 	@Operation(description = "初始化设备前检查")
 	@PostMapping("/check")
-	public ApiV1Ret<List<CheckResult>> check() throws AppException {
-		return ApiV1Ret.success(appDeviceCtrlService.checkBeforeInitDevice());
+	public ApiRet<List<CheckResult>> check() throws AppException {
+		return ApiRet.success(appDeviceCtrlService.checkBeforeInitDevice());
 	}
 
 

src/main/java/a8k/controler/api/v1/app/ctrl/OsCtrlControler.java

@@ -3,7 +3,7 @@ package a8k.controler.api.v1.app.ctrl;
 import a8k.OS;
 import a8k.controler.api.v1.type.OsInfoPack;
 import a8k.service.app.appstate.GStateService;
-import a8k.type.appret.ApiV1Ret;
+import a8k.type.appret.ApiRet;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.annotation.Resource;
@@ -28,8 +28,8 @@ public class OsCtrlControler {
 	 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 	@Operation(summary = "获取应用版本")
 	@PostMapping("/getInfo")
-	public ApiV1Ret<OsInfoPack> getInfo() {
-		return ApiV1Ret.success(new OsInfoPack() {{
+	public ApiRet<OsInfoPack> getInfo() {
+		return ApiRet.success(new OsInfoPack() {{
 			appVersion = gstate.getAppVersion();
 			mcuVersion = gstate.getMcuVersion();
 			sn         = gstate.getSn();
@@ -38,41 +38,41 @@ public class OsCtrlControler {
 
 	@Operation(summary = "获取设备IP")
 	@PostMapping("/getIp")
-	public ApiV1Ret<String> readdeviceip() {
+	public ApiRet<String> readdeviceip() {
 		//TODO:
-		return ApiV1Ret.success("192.168.8.10");
+		return ApiRet.success("192.168.8.10");
 	}
 
 	@Operation(summary = "关机(阻塞)")
 	@PostMapping("/shutdown")
-	public ApiV1Ret<Void> shutdown() {
+	public ApiRet<Void> shutdown() {
 		//TODO:
 		OS.forceSleep(5);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 	Boolean beepState = false;
 
 	@Operation(summary = "打开蜂鸣器")
 	@PostMapping("/startBeepWarning")
-	public ApiV1Ret<Void> startBeepWarning() {
+	public ApiRet<Void> startBeepWarning() {
 		log.info("打开蜂鸣器");
 		beepState = true;
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 	@Operation(summary = "关闭蜂鸣器")
 	@PostMapping("/stopBeepWarning")
-	public ApiV1Ret<Void> stopBeepWarning() {
+	public ApiRet<Void> stopBeepWarning() {
 		log.info("关闭蜂鸣器");
 		beepState = false;
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 	@Operation(summary = "获取蜂鸣器状态")
 	@PostMapping("/getBeepWarningStatus")
-	public ApiV1Ret<Boolean> getBeepWarningStatus() {
-		return ApiV1Ret.success(beepState);
+	public ApiRet<Boolean> getBeepWarningStatus() {
+		return ApiRet.success(beepState);
 	}
 
 }

src/main/java/a8k/controler/api/v1/app/data/A8kProjectCardControler.java

@@ -3,7 +3,7 @@ package a8k.controler.api.v1.app.data;
 import a8k.service.app.appdata.ProjIdCardInfoMgrService;
 import a8k.service.app.appstate.GStateService;
 import a8k.service.dao.type.A8kProjInfoCardBreif;
-import a8k.type.appret.ApiV1Ret;
+import a8k.type.appret.ApiRet;
 import a8k.type.db.CommonPage;
 import a8k.type.exception.AppException;
 import io.swagger.v3.oas.annotations.Operation;
@@ -30,35 +30,35 @@ public class A8kProjectCardControler {
 
 	@Operation(summary = "读取已挂载的A8k项目信息卡")
 	@PostMapping("/readMountedCardInfo")
-	public ApiV1Ret<A8kProjInfoCardBreif> readMountedCardInfo() throws AppException {
-		return ApiV1Ret.success(projIdCardInfoMgrService.readMountedIDCardInfo());
+	public ApiRet<A8kProjInfoCardBreif> readMountedCardInfo() throws AppException {
+		return ApiRet.success(projIdCardInfoMgrService.readMountedIDCardInfo());
 	}
 
 	@Operation(summary = "保存已挂载的A8k项目信息卡")
 	@PostMapping("/saveMountedCardInfo")
-	public ApiV1Ret<Void> saveMountedCardInfo() {
+	public ApiRet<Void> saveMountedCardInfo() {
 		projIdCardInfoMgrService.saveMountedProjInfoCard();
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 	@Operation(summary = "删除A8k项目信息")
 	@PostMapping("/delete")
-	public ApiV1Ret<Void> delete(Integer id) {
+	public ApiRet<Void> delete(Integer id) {
 		projIdCardInfoMgrService.delete(id);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 	@Operation(summary = "删除所有A8k项目信息")
 	@PostMapping("/deleteAll")
-	public ApiV1Ret<Void> deleteAll() {
+	public ApiRet<Void> deleteAll() {
 		projIdCardInfoMgrService.deleteAll();
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 	@Operation(summary = "获取A8k项目信息(Page)")
 	@PostMapping("/get")
-	public ApiV1Ret<CommonPage<A8kProjInfoCardBreif>> get(Integer pageNum, Integer pageSize) {
-		return ApiV1Ret.success(projIdCardInfoMgrService.get(pageNum, pageSize));
+	public ApiRet<CommonPage<A8kProjInfoCardBreif>> get(Integer pageNum, Integer pageSize) {
+		return ApiRet.success(projIdCardInfoMgrService.get(pageNum, pageSize));
 	}
 
 

src/main/java/a8k/controler/api/v1/app/data/A8kProjectInfoControler.java

@@ -2,7 +2,7 @@ package a8k.controler.api.v1.app.data;
 
 import a8k.service.dao.ProjectBaseInfoDao;
 import a8k.service.dao.type.ProjectBaseInfo;
-import a8k.type.appret.ApiV1Ret;
+import a8k.type.appret.ApiRet;
 import a8k.type.exception.AppException;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -27,8 +27,8 @@ public class A8kProjectInfoControler {
 
 	@Operation(summary = "读取设备支持的所有项目")
 	@PostMapping("/getAll")
-	public ApiV1Ret<List<ProjectBaseInfo>> getAll() throws AppException {
-		return ApiV1Ret.success(projectBaseInfoDao.getAll());
+	public ApiRet<List<ProjectBaseInfo>> getAll() throws AppException {
+		return ApiRet.success(projectBaseInfoDao.getAll());
 	}
 
 }

src/main/java/a8k/controler/api/v1/app/data/ReactionResultControler.java

@@ -3,7 +3,7 @@ package a8k.controler.api.v1.app.data;
 import a8k.service.app.appdata.ReactionRecordMgrService;
 import a8k.service.app.appstate.GStateService;
 import a8k.service.dao.type.ReactionResultRecord;
-import a8k.type.appret.ApiV1Ret;
+import a8k.type.appret.ApiRet;
 import a8k.type.db.CommonPage;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.annotation.Resource;
@@ -30,30 +30,30 @@ public class ReactionResultControler {
 
 
 	@PostMapping("/getAllRecords")
-	public ApiV1Ret<List<ReactionResultRecord>> getAllRecords() {
-		return ApiV1Ret.success(reactionRecordMgrService.getAll());
+	public ApiRet<List<ReactionResultRecord>> getAllRecords() {
+		return ApiRet.success(reactionRecordMgrService.getAll());
 	}
 
 	@PostMapping("/deleteAllRecords")
-	public ApiV1Ret<Void> deleteAllRecords() {
+	public ApiRet<Void> deleteAllRecords() {
 		reactionRecordMgrService.deleteAll();
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 	@PostMapping("/printfRecord")
-	public ApiV1Ret<Void> printfRecord(Integer id) {
+	public ApiRet<Void> printfRecord(Integer id) {
 		reactionRecordMgrService.printfRecord(id);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 	@PostMapping("/deleteRecord")
-	public ApiV1Ret<Void> deleteRecord(Integer id) {
+	public ApiRet<Void> deleteRecord(Integer id) {
 		reactionRecordMgrService.deleteRecord(id);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 	@PostMapping("/getRecords")
-	public ApiV1Ret<CommonPage<ReactionResultRecord>> getRecords(Integer pageNum, Integer pageSize) {
-		return ApiV1Ret.success(reactionRecordMgrService.getRecords(pageNum, pageSize));
+	public ApiRet<CommonPage<ReactionResultRecord>> getRecords(Integer pageNum, Integer pageSize) {
+		return ApiRet.success(reactionRecordMgrService.getRecords(pageNum, pageSize));
 	}
 }

src/main/java/a8k/controler/api/v1/app/data/UsrControler.java

@@ -1,19 +1,14 @@
 package a8k.controler.api.v1.app.data;
 
-import a8k.constant.FilePathConstant;
 import a8k.service.app.appdata.AppUserMgrService;
 import a8k.service.dao.type.AppUser;
 import a8k.service.dao.type.UsrRole;
-import a8k.type.appret.ApiV1Ret;
+import a8k.type.appret.ApiRet;
 import a8k.type.exception.AppException;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.annotation.Resource;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.core.io.FileSystemResource;
-import org.springframework.http.ContentDisposition;
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.*;
 
@@ -34,59 +29,59 @@ public class UsrControler {
 
 	@Operation(summary = "用户登录")
 	@PostMapping("login")
-	public ApiV1Ret<AppUser> login(Integer id, String password) throws AppException {
-		return ApiV1Ret.success(appUserMgrService.login(id, password));
+	public ApiRet<AppUser> login(Integer id, String password) throws AppException {
+		return ApiRet.success(appUserMgrService.login(id, password));
 	}
 
 
 	@Operation(summary = "用户登出")
 	@PostMapping("unlogin")
-	public ApiV1Ret<?> unlogin() {
-		return ApiV1Ret.success(appUserMgrService.unlogin());
+	public ApiRet<?> unlogin() {
+		return ApiRet.success(appUserMgrService.unlogin());
 	}
 
 
 	@Operation(summary = "获取当前用户")
 	@PostMapping("getLoginUsr")
-	public ApiV1Ret<AppUser> getLoginUsr() {
-		return ApiV1Ret.success(appUserMgrService.getLoginUsr());
+	public ApiRet<AppUser> getLoginUsr() {
+		return ApiRet.success(appUserMgrService.getLoginUsr());
 	}
 
 	@Operation(summary = "获取用户列表")
 	@PostMapping("getUsrlist")
-	public ApiV1Ret<List<AppUser>> getUsrlist() {
-		return ApiV1Ret.success(appUserMgrService.getUsrlist());
+	public ApiRet<List<AppUser>> getUsrlist() {
+		return ApiRet.success(appUserMgrService.getUsrlist());
 	}
 
 	@Operation(summary = "用户添加")
 	@PostMapping("addUser")
-	public ApiV1Ret<AppUser> addUser(String accound, String password, UsrRole role) throws AppException {
-		return ApiV1Ret.success(appUserMgrService.addUser(accound, password, role));
+	public ApiRet<AppUser> addUser(String accound, String password, UsrRole role) throws AppException {
+		return ApiRet.success(appUserMgrService.addUser(accound, password, role));
 	}
 
 	@Operation(summary = "删除用户")
 	@PostMapping("delUser")
-	public ApiV1Ret<Void> delUser(Integer id) {
-		return ApiV1Ret.success(appUserMgrService.delUser(id));
+	public ApiRet<Void> delUser(Integer id) {
+		return ApiRet.success(appUserMgrService.delUser(id));
 	}
 
 	@Operation(summary = "修改用户密码")
 	@PostMapping("modifyUsrPwd")
-	public ApiV1Ret<AppUser> modifyUsrPwd(Integer id, String password) throws AppException {
-		return ApiV1Ret.success(appUserMgrService.modifyUsrPwd(id, password));
+	public ApiRet<AppUser> modifyUsrPwd(Integer id, String password) throws AppException {
+		return ApiRet.success(appUserMgrService.modifyUsrPwd(id, password));
 	}
 
 	@Operation(summary = "修改用户权限")
 	@PostMapping("modifyUsrRole")
-	public ApiV1Ret<AppUser> modifyUsrRole(Integer id, UsrRole usrRole) throws AppException {
-		return ApiV1Ret.success(appUserMgrService.modifyUsrRole(id, usrRole));
+	public ApiRet<AppUser> modifyUsrRole(Integer id, UsrRole usrRole) throws AppException {
+		return ApiRet.success(appUserMgrService.modifyUsrRole(id, usrRole));
 
 	}
 
 	@Operation(summary = "修改用户名称")
 	@PostMapping("modifyUsrAccount")
-	public ApiV1Ret<AppUser> modifyUsrAccount(Integer id, String newaccount) throws AppException {
-		return ApiV1Ret.success(appUserMgrService.modifyUsrAccount(id, newaccount));
+	public ApiRet<AppUser> modifyUsrAccount(Integer id, String newaccount) throws AppException {
+		return ApiRet.success(appUserMgrService.modifyUsrAccount(id, newaccount));
 	}
 
 

src/main/java/a8k/controler/api/v1/app/setting/AppSettingControler.java

@@ -3,11 +3,10 @@ package a8k.controler.api.v1.app.setting;
 import a8k.service.app.appsetting.AppSettingsMgrService;
 import a8k.service.dao.type.AppSetting;
 import a8k.service.dao.type.appsetting.settingenum.*;
-import a8k.type.appret.ApiV1Ret;
+import a8k.type.appret.ApiRet;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.annotation.Resource;
-import jakarta.validation.constraints.NotNull;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.PostMapping;
@@ -30,104 +29,104 @@ public class AppSettingControler {
 
 	@Operation(summary = "获取系统设置")
 	@PostMapping("/getAppSettings")
-	public ApiV1Ret<AppSetting> getAppSettings() {
-		return ApiV1Ret.success(appSettingsMgrService.getAppSettings());
+	public ApiRet<AppSetting> getAppSettings() {
+		return ApiRet.success(appSettingsMgrService.getAppSettings());
 	}
 
 
 	@Operation(summary = "设置语言")
 	@PostMapping("/setLanguage")
-	public ApiV1Ret<Void> setLanguage(LanguageType val) {
+	public ApiRet<Void> setLanguage(LanguageType val) {
 		appSettingsMgrService.setLanguage(val);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 
 	@Operation(summary = "设置自动打印报告")
 	@PostMapping("/setAutoPrint")
-	public ApiV1Ret<Void> setAutoPrint(Boolean val) {
+	public ApiRet<Void> setAutoPrint(Boolean val) {
 		appSettingsMgrService.setAutoPrint(val);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 
 	@Operation(summary = "设置自动登出")
 	@PostMapping("/setAutoLogout")
-	public ApiV1Ret<Void> setAutoLogout(Boolean val) {
+	public ApiRet<Void> setAutoLogout(Boolean val) {
 		appSettingsMgrService.setAutoLogout(val);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 
 	@Operation(summary = "设置LIS类型")
 	@PostMapping("/setLISType")
-	public ApiV1Ret<Void> setLISType(LISTypeEnum val) {
+	public ApiRet<Void> setLISType(LISTypeEnum val) {
 		appSettingsMgrService.setLISType(val);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 
 	}
 
 
 	@Operation(summary = "设置LIS协议")
 	@PostMapping("/setLISProtocol")
-	public ApiV1Ret<Void> setLISProtocol(LISProtocolEnum val) {
+	public ApiRet<Void> setLISProtocol(LISProtocolEnum val) {
 		appSettingsMgrService.setLISProtocol(val);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 
 	}
 
 
 	@Operation(summary = "设置LIS接口")
 	@PostMapping("/setLIFIf")
-	public ApiV1Ret<Void> setLIFIf(LISIFType val) {
+	public ApiRet<Void> setLIFIf(LISIFType val) {
 		appSettingsMgrService.setLIFIf(val);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 
 	}
 
 
 	@Operation(summary = "设置LIS是否自动上报报告")
 	@PostMapping("/setLISAutoExport")
-	public ApiV1Ret<Void> setLISAutoExport(Boolean val) {
+	public ApiRet<Void> setLISAutoExport(Boolean val) {
 		appSettingsMgrService.setLISAutoExport(val);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 
 	}
 
 
 	@Operation(summary = "设置LIS串口波特率")
 	@PostMapping("/setLISSerialBaudrate")
-	public ApiV1Ret<Void> setLISSerialBaudrate(LISSerialBaudrateType val) {
+	public ApiRet<Void> setLISSerialBaudrate(LISSerialBaudrateType val) {
 		appSettingsMgrService.setLISSerialBaudrate(val);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 
 	}
 
 
 	@Operation(summary = "设置LISIP")
 	@PostMapping("/setLISNetIp")
-	public ApiV1Ret<Void> setLISNetIp(String val) {
+	public ApiRet<Void> setLISNetIp(String val) {
 		appSettingsMgrService.setLISNetIp(val);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 
 	}
 
 
 	@Operation(summary = "设置LIS端口")
 	@PostMapping("/setLISNetPort")
-	public ApiV1Ret<Void> setLISNetPort(Integer val) {
+	public ApiRet<Void> setLISNetPort(Integer val) {
 		appSettingsMgrService.setLISNetPort(val);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 
 	}
 
 
 	@Operation(summary = "设置设备温度")
 	@PostMapping("/setTemperature")
-	public ApiV1Ret<Void> setTemperature(Integer val) {
+	public ApiRet<Void> setTemperature(Integer val) {
 		log.info("setTemperature:{}", val);
 		appSettingsMgrService.setTemperature(val);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 }

src/main/java/a8k/controler/api/v1/app/state/AppTubeSettingMgrControler.java

@@ -2,7 +2,7 @@ package a8k.controler.api.v1.app.state;
 
 import a8k.service.app.appctrl.AppTubeSettingMgrService;
 import a8k.service.app.appstate.GStateService;
-import a8k.type.appret.ApiV1Ret;
+import a8k.type.appret.ApiRet;
 import a8k.type.exception.AppException;
 import a8k.type.tube_setting.TubeHolderSetting;
 import a8k.type.tube_setting.TubeSetting;
@@ -36,37 +36,37 @@ public class AppTubeSettingMgrControler {
 
 	@Operation(summary = "获取试管架配置")
 	@PostMapping("/getSettings")
-	public ApiV1Ret<List<TubeHolderSetting>> getTubeHolderSettings() {
-		return ApiV1Ret.success(appTubeSettingMgrService.getTubeHolderSettings());
+	public ApiRet<List<TubeHolderSetting>> getTubeHolderSettings() {
+		return ApiRet.success(appTubeSettingMgrService.getTubeHolderSettings());
 	}
 
 	@Operation(summary = "配置试管")
 	@PostMapping("/updateTubeSetting")
-	public ApiV1Ret<Void> updateTubeSetting(@RequestBody String uuid, @RequestBody TubeSetting setting) throws AppException {
+	public ApiRet<Void> updateTubeSetting(@RequestBody String uuid, @RequestBody TubeSetting setting) throws AppException {
 		appTubeSettingMgrService.updateTubeSetting(uuid, setting);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 	//添加试管架，返回整个列表
 	@Operation(summary = "添加<试管架>配置")
 	@PostMapping("/newTubeHolderSetting")
-	public ApiV1Ret<Void> newTubeHolderSetting() {
+	public ApiRet<Void> newTubeHolderSetting() {
 		appTubeSettingMgrService.newTubeHolderSetting();
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 	@Operation(summary = "删除<试管架>配置")
 	@PostMapping("/removeTubeHolderSetting")
-	public ApiV1Ret<Void> removeTubeHolderSetting(String uuid) throws AppException {
+	public ApiRet<Void> removeTubeHolderSetting(String uuid) throws AppException {
 		appTubeSettingMgrService.removeTubeHolderSetting(uuid);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 	@Operation(summary = "设置<试管架>激活状态")
 	@PostMapping("/updateActiveState")
-	public ApiV1Ret<Void> updateActiveState(String uuid, Boolean active) throws AppException {
+	public ApiRet<Void> updateActiveState(String uuid, Boolean active) throws AppException {
 		appTubeSettingMgrService.updateActiveState(uuid, active);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 	//	@Operation(summary = "设置<试管架>类型")

src/main/java/a8k/controler/api/v1/app/state/ConsumablesMgrControler.java

@@ -4,7 +4,7 @@ import a8k.service.app.appctrl.AppConsumablesScanService;
 import a8k.service.app.appstate.statemgr.ConsumablesMgrService;
 import a8k.service.app.appstate.GStateService;
 import a8k.type.ConsumableGroup;
-import a8k.type.appret.ApiV1Ret;
+import a8k.type.appret.ApiRet;
 import a8k.type.consumables.ConsumableState;
 import a8k.type.type.TipGroup;
 import io.swagger.v3.oas.annotations.Operation;
@@ -36,9 +36,9 @@ public class ConsumablesMgrControler {
 	 */
 	@Operation(summary = "设置Tip数量", description = "只允许在设备暂停或者停止状态下调用")
 	@PostMapping("/setTipNum")
-	synchronized public ApiV1Ret<Void> setTipNum(TipGroup group, Integer num) {
+	synchronized public ApiRet<Void> setTipNum(TipGroup group, Integer num) {
 		consumablesMgrService.setTipNum(group, num);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 	/**
@@ -48,14 +48,14 @@ public class ConsumablesMgrControler {
 	 */
 	@Operation(summary = "设置耗材数量", description = "只允许在设备暂停或者停止状态下调用")
 	@PostMapping("/setCounsumableNum")
-	synchronized public ApiV1Ret<Void> setCounsumableNum(ConsumableGroup group, Integer num) {
+	synchronized public ApiRet<Void> setCounsumableNum(ConsumableGroup group, Integer num) {
 		consumablesMgrService.setCounsumableNum(group, num);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 	@Operation(summary = "获取<耗材>状态")
 	@PostMapping("/getConsumablesState")
-	public ApiV1Ret<ConsumableState> getConsumablesState() {
-		return ApiV1Ret.success(consumablesMgrService.getState());
+	public ApiRet<ConsumableState> getConsumablesState() {
+		return ApiRet.success(consumablesMgrService.getState());
 	}
 }

src/main/java/a8k/controler/api/v1/app/state/DeviceStateControler.java

@@ -7,8 +7,7 @@ import a8k.service.app.appstate.statemgr.IncubationPlateStateMgrService;
 import a8k.service.app.appstate.statemgr.OptScanModuleStateMgrService;
 import a8k.service.app.appstate.statemgr.TubeStateMgrService;
 import a8k.service.app.appstate.type.*;
-import a8k.type.appret.ApiV1Ret;
-import a8k.type.consumables.ConsumableState;
+import a8k.type.appret.ApiRet;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.annotation.Resource;
@@ -41,39 +40,39 @@ public class DeviceStateControler {
 
 	@Operation(summary = "获取主流程工作状态")
 	@PostMapping("/getDeviceWorkState")
-	public ApiV1Ret<DeviceWorkState> getDeviceWorkState() {
-		return ApiV1Ret.success(deviceWorkStateMgrService.getDeviceWorkState());
+	public ApiRet<DeviceWorkState> getDeviceWorkState() {
+		return ApiRet.success(deviceWorkStateMgrService.getDeviceWorkState());
 	}
 
 	@Operation(summary = "获取<试管架>状态")
 	@PostMapping("/getTubeHolderState")
-	public ApiV1Ret<TubeHolder> getTubeHolderState() {
-		return ApiV1Ret.success(tubeStateMgrService.getTubeHolder());
+	public ApiRet<TubeHolder> getTubeHolderState() {
+		return ApiRet.success(tubeStateMgrService.getTubeHolder());
 	}
 
 	@Operation(summary = "获取<孵育盘>的状态")
 	@PostMapping("/getIncubationPlate")
-	public ApiV1Ret<IncubationPlate> getIncubationPlate() {
-		return ApiV1Ret.success(incubationPlateStateMgrService.get());
+	public ApiRet<IncubationPlate> getIncubationPlate() {
+		return ApiRet.success(incubationPlateStateMgrService.get());
 	}
 
 	@Operation(summary = "获取<光学模组>状态")
 	@PostMapping("/getOptScanModuleState")
-	public ApiV1Ret<OptScanModule> getOptScanModuleState() {
-		return ApiV1Ret.success(optScanModuleStateMgrService.getOptScanModule());
+	public ApiRet<OptScanModule> getOptScanModuleState() {
+		return ApiRet.success(optScanModuleStateMgrService.getOptScanModule());
 	}
 
 	@Operation(summary = "获取<急诊位>状态")
 	@PostMapping("/getEmergencyTubePosState")
-	public ApiV1Ret<EmergencyTubePos> getEmergencyTubePosState() {
-		return ApiV1Ret.success(tubeStateMgrService.getEmergencyPosRunState());
+	public ApiRet<EmergencyTubePos> getEmergencyTubePosState() {
+		return ApiRet.success(tubeStateMgrService.getEmergencyPosRunState());
 	}
 
 
 	@Operation(summary = "获取<传感器>状态")
 	@PostMapping("/getSensorState")
-	public ApiV1Ret<SensorState> getSensorState() {
-		return ApiV1Ret.success(gstate.getSensorState());
+	public ApiRet<SensorState> getSensorState() {
+		return ApiRet.success(gstate.getSensorState());
 	}
 
 

src/main/java/a8k/controler/api/v1/app/state/EmergencyTubeControler.java

@@ -4,7 +4,7 @@ package a8k.controler.api.v1.app.state;
 import a8k.controler.api.v1.type.EmergencyTubeSetting;
 import a8k.service.app.appstate.GStateService;
 import a8k.service.app.appstate.statemgr.TubeStateMgrService;
-import a8k.type.appret.ApiV1Ret;
+import a8k.type.appret.ApiRet;
 import a8k.type.exception.AppException;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -30,14 +30,14 @@ public class EmergencyTubeControler {
 
 	@Operation(summary = "提交紧急样本设置")
 	@PostMapping("/addNew")
-	public ApiV1Ret<Void> addNew(@RequestBody EmergencyTubeSetting setting) throws AppException {
+	public ApiRet<Void> addNew(@RequestBody EmergencyTubeSetting setting) throws AppException {
 		tubeStateMgrService.commitEmergencySampleSetting(
 				setting.getUserid(),
 				setting.getSampleBarcode(),
 				setting.getBloodType(),
 				setting.getProjIds()
 		);
-		return ApiV1Ret.success();
+		return ApiRet.success();
 	}
 
 }

src/main/java/a8k/controler/filemgr/OptFileMgrController.java

@@ -1,10 +1,8 @@
 package a8k.controler.filemgr;
 
 import a8k.service.app.appdata.FileMgrService;
-import a8k.type.appret.ApiV1Ret;
 import a8k.type.appret.AppRetV1;
 import cn.hutool.core.net.URLDecoder;
-import jakarta.annotation.PostConstruct;
 import jakarta.annotation.Resource;
 import jakarta.servlet.http.HttpServletRequest;
 import lombok.extern.slf4j.Slf4j;

src/main/java/a8k/factory/ZAppPromoptFactory.java

@@ -0,0 +1,120 @@
+package a8k.factory;
+
+import a8k.i18n.Internationalization;
+import a8k.service.app.appctrl.mainflowctrl.base.AppActionErrorContext;
+import a8k.service.bases.appevent.A8kEcodeContextListPromptEvent;
+import a8k.service.bases.appevent.A8kErrorsPromptEvent;
+import a8k.service.bases.appevent.AppPromptEvents;
+import a8k.type.ecode.*;
+import a8k.type.exception.AppException;
+import a8k.type.ui.ZAppErrorStackInfo;
+import a8k.type.ui.ZAppPromopt;
+import a8k.type.ui.ZAppPromoptDetailInfo;
+import a8k.type.ui.ZAppPromoptType;
+import jakarta.validation.ValidationException;
+import org.springframework.web.method.annotation.HandlerMethodValidationException;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ZAppPromoptFactory {
+
+
+	public static ZAppErrorStackInfo buildErrorStackInfo(StackTraceElement[] stack) {
+		ZAppErrorStackInfo stackInfo = new ZAppErrorStackInfo();
+		List<String>       stackList = new ArrayList<>();
+		for (StackTraceElement element : stack) {
+			stackList.add(element.toString());
+		}
+		stackInfo.stackTraceElements = stackList.toArray(new String[0]);
+		return stackInfo;
+	}
+
+
+	public static ZAppPromopt buildAppPromopt(AppError error) {
+		if (error instanceof AECodeError ecodeError) {
+			ZAppPromopt promopt = new ZAppPromopt();
+			promopt.type      = ZAppPromoptType.Error;
+			promopt.info      = ecodeError.exmsg;
+			promopt.stackInfo = buildErrorStackInfo(ecodeError.stackTraceElements);
+			return promopt;
+		} else if (error instanceof AEHardwareError appError) {
+			ZAppPromopt promopt = new ZAppPromopt();
+			promopt.type = ZAppPromoptType.Fatal;
+			if (appError.exmsg != null && !appError.exmsg.isEmpty()) {
+				promopt.info = appError.exmsg;
+			} else {
+				promopt.info = Internationalization.A8kEcode2String(appError.code);
+			}
+			if (appError.mid != null)
+				promopt.detailInfos.add(new ZAppPromoptDetailInfo("相关模块", appError.mid.chname));
+			if (appError.cmdId != null)
+				promopt.detailInfos.add(new ZAppPromoptDetailInfo("相关指令", appError.cmdId.chName));
+			return promopt;
+		} else if (error instanceof AEConsumeNotEnoughError appError) {
+			ZAppPromopt promopt = new ZAppPromopt();
+			promopt.type = ZAppPromoptType.Warn;
+			promopt.info = String.format("项目[%s] 耗材不足", appError.projName);
+			return promopt;
+		} else if (error instanceof AETubeError appError) {
+			ZAppPromopt promopt = new ZAppPromopt();
+			promopt.type = ZAppPromoptType.Error;
+			promopt.info = String.format("试管%s %s", appError.tubeOff + 1, Internationalization.A8kEcode2String(appError.code));
+			return promopt;
+		} else {
+			ZAppPromopt promopt = new ZAppPromopt();
+			promopt.type = ZAppPromoptType.Error;
+			promopt.info = Internationalization.A8kEcode2String(error.code);
+			if (error.exmsg != null)
+				promopt.detailInfos.add(new ZAppPromoptDetailInfo("额外信息", error.exmsg));
+			return promopt;
+		}
+	}
+
+
+	public static ZAppPromopt buildAppPromopt(Exception e) {
+		if (e instanceof AppException hexcep) {
+			return buildAppPromopt(hexcep.error);
+		} else if (e instanceof ValidationException ex) {
+			ZAppPromopt promopt = new ZAppPromopt();
+			promopt.type      = ZAppPromoptType.Error;
+			promopt.info      = ex.getMessage();
+			promopt.stackInfo = buildErrorStackInfo(ex.getStackTrace());
+			return promopt;
+		} else if (e instanceof HandlerMethodValidationException validationE) {
+			ZAppPromopt promopt = new ZAppPromopt();
+			promopt.type      = ZAppPromoptType.Error;
+			promopt.info      = validationE.getMessage();
+			promopt.stackInfo = buildErrorStackInfo(validationE.getStackTrace());
+			return promopt;
+		} else {
+			ZAppPromopt promopt = new ZAppPromopt();
+			promopt.type      = ZAppPromoptType.Error;
+			promopt.info      = e.getMessage();
+			promopt.stackInfo = buildErrorStackInfo(e.getStackTrace());
+			return promopt;
+		}
+	}
+
+
+	public static AppPromptEvents buildAppPromptEvents(A8kEcodeContextListPromptEvent e) {
+		List<ZAppPromopt> prompts = new java.util.ArrayList<>();
+		for (AppActionErrorContext ecode : e.ecodeList) {
+			ZAppPromopt prompt = new ZAppPromopt();
+			prompt.type = ZAppPromoptType.Error;
+			prompt.info = String.format("执行%s发生错误", Internationalization.a8kActionStepTypeToDisplayStr(ecode.dowhat));
+			prompt.detailInfos.add(new ZAppPromoptDetailInfo("错误", Internationalization.A8kEcode2String(ecode.ecode.code)));
+		}
+		return new AppPromptEvents(prompts);
+	}
+
+	public static AppPromptEvents buildAppPromptEvents(A8kErrorsPromptEvent e) {
+		List<ZAppPromopt> prompts = new java.util.ArrayList<>();
+		for (AppError error : e.errors) {
+			prompts.add(ZAppPromoptFactory.buildAppPromopt(error));
+		}
+		return new AppPromptEvents(prompts);
+
+	}
+
+}

src/main/java/a8k/hardware/type/a8kcanprotocol/CmdId.java

@@ -115,36 +115,21 @@ public enum CmdId {
 	pipette_zmotor_read_measure_distance_result(0x7404, "pipette_zmotor_read_measure_distance_result"),
 	pipette_zmotor_move_by(0x7405, "pipette_zmotor_move_by"),
 	pipette_zmotor_move_to(0x7406, "pipette_zmotor_move_to"),
-	pipette_init_device(0x7407, "pipette_init_device"),
-	pipette_put_tip(0x7408, "pipette_put_tip"),
-	pipette_lld_prepare(0x7409, "pipette_lld_prepare"),
-	pipette_lld(0x740A, "pipette_lld"),
-	pipette_aspirate_prepare(0x740B, "pipette_aspirate_prepare"),
-	pipette_aspirate_set_llf_velocity(0x740C, "pipette_aspirate_set_llf_velocity"),
-	pipette_aspirate_set_operation_verifi_p_thre(0x740D, "pipette_aspirate_set_operation_verifi_p_thre"),
-	pipette_aspirate_set_operation_verifi_eigen_time(0x740E, "pipette_aspirate_set_operation_verifi_eigen_time"),
-	pipette_aspirate_set_operation_verifi_tolerance(0x740F, "pipette_aspirate_set_operation_verifi_tolerance"),
-	pipette_aspirate(0x7410, "pipette_aspirate"),
-	pipette_aspirate_and_verify(0x7411, "pipette_aspirate_and_verify"),
-	pipette_shake_up(0x7412, "pipette_shake_up"),
-	pipette_aspirate_infer_pressure(0x7413, "pipette_aspirate_infer_pressure"),
-	pipette_aspirate_infer_eigen_time(0x7414, "pipette_aspirate_infer_eigen_time"),
-	pipette_get_aspirate_infer_pressure_result(0x7415, "pipette_get_aspirate_infer_pressure_result"),
-	pipette_get_aspirate_infer_eigen_time_result(0x7416, "pipette_get_aspirate_infer_eigen_time_result"),
-	pipette_get_sensor_sample_data(0x7417, "pipette_get_sensor_sample_data"),
-	pipette_get_sensor_sample_data_num(0x7418, "pipette_get_sensor_sample_data_num"),
-	pipette_zmotor_read_zero_point_state(0x7419, "pipette_zmotor_read_zero_point_state"),
-	pipette_zmotor_read_dev_status_cache(0x741A, "pipette_zmotor_read_dev_status_cache"),
-	pipette_lld_is_detect_liquid(0x741B, "kpipette_lld_is_detect_liquid"),
-	pipette_lld_test(0x741C, "pipette_lld_test"),
-	pipette_set_lld_startz(0x741D, "移动枪设置移动开始高度"),
-	pipette_set_lld_endz(0x741E, "移动枪设置移动最大高度"),
-	pipette_set_lld_type(0x741F, "移动枪设置液面探测类型"),
-	pipette_set_lld_c_threshold(0x7420, "移动枪设置液面探测电容阈值"),
-	pipette_set_lld_p_threshold(0x7421, "移动枪设置液面探测压力阈值"),
-	kpipette_set_llf_startz(0x7422, "移动枪设置液面跟随开始限制高度"),
-	kpipette_set_llf_endz(0x7423, "移动枪设置液面跟随结束限制高度"),
-	kpipette_clear_hanging_liquid(0x7424, "移动枪清除悬液"),
+
+	pipette_init_device(0x7501, "pipette_init_device"),
+	pipette_put_tip(0x7502, "pipette_put_tip"),
+	pipette_pump_move_to(0x7503, "pipette_pump_move_to"),
+	pipette_lld(0x7504, "pipette_lld"),
+	pipette_aspirate(0x7505, "pipette_aspirate"),
+	pipette_distribu(0x7506, "pipette_distribu"),
+	pipette_shake_up(0x7507, "pipette_shake_up"),
+	pipette_clear_hanging_liquid(0x7508, "pipette_clear_hanging_liquid"),
+	pipette_get_sensor_sample_data(0x7510, "pipette_get_sensor_sample_data"),
+	pipette_get_sensor_sample_data_num(0x7511, "pipette_get_sensor_sample_data_num"),
+	pipette_zmotor_read_zero_point_state(0x7512, "pipette_zmotor_read_zero_point_state"),
+	pipette_zmotor_read_dev_status_cache(0x7513, "pipette_zmotor_read_dev_status_cache"),
+
+
 	;
 
 

src/main/java/a8k/i18n/Internationalization.java

@@ -0,0 +1,65 @@
+package a8k.i18n;
+
+import a8k.hardware.type.a8kcanprotocol.A8kEcode;
+import a8k.service.app.appctrl.mainflowctrl.base.A8kActionStepType;
+
+public class Internationalization {
+	public static String A8kEcode2String(A8kEcode ecode) {
+		return switch (ecode) {
+			case SUC -> "成功";
+			case CODEERROR -> "代码错误";
+			case PE_PARAM_OUT_OF_RANGE -> "参数超出范围";
+			case USR_ALREADY_EXIST -> "用户已存在";
+			case USR_NOT_EXIT -> "用户不存在";
+			case USR_PASSWORD_ERROR -> "用户密码错误";
+			case APPE_A8K_ID_CARD_NOT_MOUNTED -> "ID卡未挂载";
+			case APPE_TUBE_HOLDER_SETTING_IS_LOCKED -> "试管架设置被锁定,已锁定的.";
+			case APPE_EMERGENCY_SAMPLE_IS_PROCESSING -> "添加急诊样本失败，急诊样本还没有处理完成";
+			case APPE_ADD_EMERGENCY_ACTION_IS_NOT_ALLOWED_WHEN_WORKING -> "添加急诊样本失败，设备正在运行中";
+			case APPE_DEVICE_IS_IN_FATAL_ERROR -> "设备处于严重错误,请关机后重启设备进行恢复";
+			case APPE_SCAN_TUBEHOLDER_TYPE_TIMEOUT -> "扫描试管架类型超时";
+			case APPE_TUBE_HOLDER_TYPE_IS_NOT_SUPPORT -> "试管架类型不支持";
+			case APPE_INFEED_OVERTIME_FAIL -> "入料超时失败";
+			case APPE_PUT_TIP_FAIL -> "丢弃Tip失败";
+			case APPE_TAKE_TIP_FAIL -> "取Tip失败";
+			case APPE_EJECT_TUBEHOLDER_TIMEOUT -> "弹出试管架超时";
+			case APPE_NO_TUBE_IN_HOLDER -> "试管架中没有试管";
+			case APPE_CONSUME_NOT_ENOUGH -> "耗材不足";
+			case APPE_TIP_NOT_ENOUGH -> "tip不足";
+			case APPE_A8K_PROJ_CARD_PARSE_ERROR -> "ID卡解析错误";
+			case APPE_A8K_PROJ_CARD_EXPIRYED -> "ID卡过期";
+			case APPE_A8K_PROJ_ID_IS_EMPTY -> "项目ID为空";
+			case APPE_A8K_PROJ_UNSUPPORTED -> "项目不支持";
+			case APPE_A8K_PROJ_INFO_IS_ERROR -> "项目信息异常";
+			case APPE_PULLERM_INIT_POS_ERROR -> "初始化阶段，拉板电机没有处于零点位置";
+			case APPE_PUSHERM_INIT_POS_ERROR -> "初始化阶段，推板电机没有处于零点位置";
+			case APPE_PLATE_STUCK_DETECTOR_SENSOR_TRIGGER -> "卡板检测传感器触发";
+			case APPE_TUBE_X_CHANNEL_IS_NOT_EMPTY -> "试管架通道有异物";
+			case APPE_PLATE_BOX_NOT_COVER -> "板夹仓未盖";
+			case APPE_DEVICE_NOT_INITED -> "设备未初始化";
+			default -> ecode.toString();
+		};
+	}
+
+	public static String a8kActionStepTypeToDisplayStr(A8kActionStepType actionType) {
+		return switch (actionType) {
+			case DO_START -> "启动";
+			case DO_PAUSE -> "暂停";
+			case DO_STOP -> "停止";
+			case DO_RESUME -> "恢复";
+			case SEQ1_ENTER_TUBEHOLDER_AND_SCAN -> "入料并扫描";
+			case SEQ2_SWITCH_TO_THE_NEXT_TUBE -> "切换到下一个试管";
+			case SEQ3_APPLAY_RESOURCE -> "申请资源";
+			case SEQ4_PRE_PROCESS -> "样本预处理";
+			case SEQ5_PROCESS -> "样本处理中";
+			case SEQ6_POST_PROCESS -> "样本后处理";
+			case SEQ7_EJECT_TUBEHOLDER -> "弹出试管架";
+			case PROCESS_INCUBATE_COMPLETED_PLATE -> "处理孵育完成的板";
+			case PLATE_OPT_SCAN -> "光学扫描";
+			case DO_CLEAR_ERROR_BEFORE_WORK -> "在启动前，清除错误";
+			case DO_FINISH_TUBE_PROCESS -> "处理异常的样本";
+			case DO_PROCESS_ERROR_PLATE -> "处理异常的孵育盘";
+		};
+	}
+
+}

src/main/java/a8k/service/app/devicectrl/driver/PipetteCtrlDriver.java

@@ -53,35 +53,20 @@ public class PipetteCtrlDriver {
 		public static final int initDeviceBlock                 = 9;
 		public static final int putTipBlock                     = 11;
 
-		public static final int setLLDStartZ        = 20;
-		public static final int setLLDEndZ          = 21;
-		public static final int setLldType          = 22;
-		public static final int setLldCThreshold    = 23;
-		public static final int setLldPThreshold    = 24;
-		public static final int lldPrepareBlock     = 25;
-		public static final int lldBlock            = 26;
-		public static final int lldCalibrationBlock = 27;
-		public static final int lldIsDetectLiquid   = 28;
+
 		public static final int getSensorSampleData = 29;
 		public static final int readCapacitance     = 30;
 
-		public static final int aspiratePrepareBlock                 = 30;
-		public static final int aspirateSetLlfVelocity               = 31;
-		public static final int setLlfStartZ                         = 32;
-		public static final int setLlfEndZ                           = 33;
-		public static final int aspirateSetOperationVerifPThre       = 34;
-		public static final int aspirateSetOperationVerifEigenTime   = 35;
-		public static final int aspirateSetOperationVerifTolerance   = 36;
-		public static final int aspirateBlock                        = 37;
-		public static final int aspirateAndVerifyBlock               = 38;
-		public static final int shakeUpBlock                         = 39;
-		public static final int aspirateInferPressureBlock           = 40;
-		public static final int aspirateInferEigenTimeBlock          = 41;
-		public static final int getAspirateInferPressureResult       = 42;
-		public static final int getAspirateInferEigenTimeResultBlock = 43;
 
+		public static final int pipetteInitDevice         = 31;
+		public static final int pipettePutTip             = 32;
+		public static final int pipettePumpMoveTo         = 33;
+		public static final int pipetteLld                = 34;
+		public static final int pipetteAspirate           = 35;
+		public static final int pipetteDistribu           = 36;
+		public static final int pipetteShakeUp            = 37;
+		public static final int pipetteClearHangingLiquid = 38;
 
-		public static final int zAixsZeroPointIsTrigger = 50;
 
 		public static final int setReg     = 100;
 		public static final int getReg     = 101;
@@ -153,62 +138,34 @@ public class PipetteCtrlDriver {
 		canBusService.waitForMod(MId.PipetteMod, overtime);
 	}
 
-	@ExtApiFn(name = "设置LLD起始位置", order = FnOrder.setLLDStartZ)
 	public void setStartZ(Integer startZ) throws AppException {
-		log.info("setStartZ:{}", startZ);
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_set_lld_startz.toInt(), startZ);
 	}
 
-	@ExtApiFn(name = "设置LLD结束位置", order = FnOrder.setLLDEndZ)
 	public void setEndZ(Integer endZ) throws AppException {
-		log.info("setEndZ:{}", endZ);
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_set_lld_endz.toInt(), endZ);
 	}
 
-	@ExtApiFn(name = "设置LLD类型", order = FnOrder.setLldType)
 	public void setLldType(LldType lldType) throws AppException {
-		log.info("setLldType:{}", lldType);
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_set_lld_type.toInt(), lldType.getIndex());
 	}
 
-	@ExtApiFn(name = "设置LLD.C阈值", order = FnOrder.setLldCThreshold)
 	public void setLldCThreshold(Integer cThreshold) throws AppException {
-		log.info("setLldCThreshold:{}", cThreshold);
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_set_lld_c_threshold.toInt(), cThreshold);
 	}
 
-	@ExtApiFn(name = "设置LLD.P阈值", order = FnOrder.setLldPThreshold)
 	public void setLldPThreshold(Integer pThreshold) throws AppException {
-		log.info("setLldPThreshold:{}", pThreshold);
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_set_lld_p_threshold.toInt(), pThreshold);
 	}
 
-	@ExtApiFn(name = "LLD.准备", order = FnOrder.lldPrepareBlock)
 	public void lldPrepareBlock() throws AppException {
-		log.info("lldPrepareBlock");
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_lld_prepare.toInt());
-		canBusService.waitForMod(MId.PipetteMod, overtime);
 		//		zMotorMoveToBlock(startPos);
 	}
 
-	@ExtApiFn(name = "LLD.Do", order = FnOrder.lldBlock)
-	public void lldBlock()
-			throws AppException {
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_lld.toInt());
-		canBusService.waitForMod(MId.PipetteMod, overtime);
+	public void lldBlock() throws AppException {
 	}
 
-	@ExtApiFn(name = "LLD.参数标定", order = FnOrder.lldCalibrationBlock)
 	public void lldCalibrationBlock() throws AppException {
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_lld_test.toInt());
-		canBusService.waitForMod(MId.PipetteMod, overtime);
 	}
 
 	//	kpipette_lld_is_detect_liquid
-	@ExtApiFn(name = "LLD.读取是否检测到液体", order = FnOrder.lldIsDetectLiquid)
 	public Boolean lldIsDetectLiquid() throws AppException {
-		var receipt = canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_lld_is_detect_liquid.toInt());
-		return receipt.getContentI32(0) == 1;
+		return false;
 	}
 
 
@@ -242,96 +199,111 @@ public class PipetteCtrlDriver {
 	}
 
 
-	@ExtApiFn(name = "吸液准备", order = FnOrder.aspiratePrepareBlock)
 	public void aspiratePrepareBlock() throws AppException {
-		//		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_aspirate_prepare.toInt());
-		//		canBusService.waitForMod(MId.PipetteMod, overtime);
 	}
 
-	@ExtApiFn(name = "设置LLF速度", order = FnOrder.aspirateSetLlfVelocity)
 	public void aspirateSetLlfVelocity(Integer llf_zm_rpm) throws AppException {
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_aspirate_set_llf_velocity.toInt(), llf_zm_rpm);
 	}
-	//	kpipette_set_llf_startz
-	//kpipette_set_llf_endz
 
-	@ExtApiFn(name = "设置LLF起始位置", order = FnOrder.setLlfStartZ)
 	public void setLlfStartZ(Integer startZ) throws AppException {
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.kpipette_set_llf_startz.toInt(), startZ);
 	}
 
-	@ExtApiFn(name = "设置LLF结束位置", order = FnOrder.setLlfEndZ)
 	public void setLlfEndZ(Integer endZ) throws AppException {
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.kpipette_set_llf_endz.toInt(), endZ);
 	}
 
-	@ExtApiFn(name = "设置操作验证压力阈值", order = FnOrder.aspirateSetOperationVerifPThre)
 	public void aspirateSetOperationVerifPThre(Integer p_thre) throws AppException {
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_aspirate_set_operation_verifi_p_thre.toInt(),
-				p_thre);
 	}
 
-	@ExtApiFn(name = "设置操作验证时间", order = FnOrder.aspirateSetOperationVerifEigenTime)
 	public void aspirateSetOperationVerifEigenTime(Integer eigen_time) throws AppException {
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_aspirate_set_operation_verifi_eigen_time.toInt(),
-				eigen_time);
 	}
 
-	@ExtApiFn(name = "设置操作验证容忍度", order = FnOrder.aspirateSetOperationVerifTolerance)
 	public void aspirateSetOperationVerifTolerance(Integer tolerance) throws AppException {
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_aspirate_set_operation_verifi_tolerance.toInt(),
-				tolerance);
 	}
 
-	@ExtApiFn(name = "吸液", order = FnOrder.aspirateBlock)
 	public void aspirateBlock(Integer ul) throws AppException {
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_aspirate.toInt(), ul);
-		canBusService.waitForMod(MId.PipetteMod, overtime);
 	}
 
-	@ExtApiFn(name = "吸液并验证", order = FnOrder.aspirateAndVerifyBlock)
 	public void aspirateAndVerifyBlock(Integer ul) throws AppException {
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_aspirate_and_verify.toInt(), ul);
-		canBusService.waitForMod(MId.PipetteMod, overtime);
 	}
 
-	@ExtApiFn(name = "振荡", order = FnOrder.shakeUpBlock)
 	public void shakeUpBlock(Integer ul, Integer times) throws AppException {
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_shake_up.toInt(), ul, times);
-		canBusService.waitForMod(MId.PipetteMod, overtime + times * 3000);
 	}
 
-	@ExtApiFn(name = "清除悬液", order = FnOrder.shakeUpBlock)
 	public void clearHangingLiquid(Integer repeatTimes) throws AppException {
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.kpipette_clear_hanging_liquid.toInt(), repeatTimes);
-		canBusService.waitForMod(MId.PipetteMod, overtime);
 	}
 
-	@ExtApiFn(name = "吸液推算压力", order = FnOrder.aspirateInferPressureBlock)
 	public void aspirateInferPressureBlock(Integer ul) throws AppException {
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_aspirate_infer_pressure.toInt(), ul);
-		canBusService.waitForMod(MId.PipetteMod, overtime);
 	}
 
-	@ExtApiFn(name = "吸液推算时间", order = FnOrder.aspirateInferEigenTimeBlock)
 	public void aspirateInferEigenTimeBlock(Integer ul) throws AppException {
-		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_aspirate_infer_eigen_time.toInt(), ul);
-		canBusService.waitForMod(MId.PipetteMod, overtime);
 	}
 
-	@ExtApiFn(name = "获取吸液推算压力结果", order = FnOrder.getAspirateInferPressureResult)
 	public Integer getAspirateInferPressureResult() throws AppException {
-		var receipt = canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_get_aspirate_infer_pressure_result.toInt());
-		return receipt.getContentI32(0);
+		return 0;
 	}
 
-	@ExtApiFn(name = "获取吸液推算时间结果", order = FnOrder.getAspirateInferEigenTimeResultBlock)
 	public Integer getAspirateInferEigenTimeResultBlock() throws AppException {
-		var receipt = canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_get_aspirate_infer_eigen_time_result.toInt());
-		return receipt.getContentI32(0);
+		return 0;
+	}
+
+	//  virtual int32_t pipette_init_device();
+	//  virtual int32_t pipette_put_tip();
+	//  virtual int32_t pipette_pump_move_to(int32_t pumpv, int32_t ul);
+	//  virtual int32_t pipette_lld(int32_t lldtype, int32_t maxzpos, int32_t c_threshold, int32_t p_threshold);
+	//  virtual int32_t pipette_aspirate(int32_t llfrpm, int32_t llftpos, int32_t pumpv, int32_t ul);
+	//  virtual int32_t pipette_distribu(int32_t llfrpm, int32_t pumpv, int32_t ul);
+	//  virtual int32_t pipette_shake_up(int32_t llfrpm, int32_t maxzpos, int32_t pumpv, int32_t ul, int32_t times);
+
+	@ExtApiFn(name = "初始化设备", order = FnOrder.pipetteInitDevice)
+	public void pipetteInitDevice() throws AppException {
+		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_init_device.toInt());
+		canBusService.waitForMod(MId.PipetteMod, overtime);
+	}
+
+	@ExtApiFn(name = "放置吸头", order = FnOrder.pipettePutTip)
+	public void pipettePutTip() throws AppException {
+		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_put_tip.toInt());
+		canBusService.waitForMod(MId.PipetteMod, overtime);
 	}
 
-	@ExtApiFn(name = "z轴零点是否触发", order = FnOrder.zAixsZeroPointIsTrigger)
+	@ExtApiFn(name = "泵移动到", order = FnOrder.pipettePumpMoveTo)
+	public void pipettePumpMoveTo(Integer pumpv, Integer ul) throws AppException {
+		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_pump_move_to.toInt(), pumpv, ul);
+		canBusService.waitForMod(MId.PipetteMod, overtime);
+	}
+
+	@ExtApiFn(name = "LLD", order = FnOrder.pipetteLld)
+	public void pipetteLld(LldType lldtype, Integer maxzpos, Integer c_threshold, Integer p_threshold) throws AppException {
+		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_lld.toInt(), lldtype.getIndex(), maxzpos, c_threshold, p_threshold);
+		canBusService.waitForMod(MId.PipetteMod, overtime);
+	}
+
+	@ExtApiFn(name = "吸液", order = FnOrder.pipetteAspirate)
+	public void pipetteAspirate(Integer llfrpm, Integer llftpos, Integer pumpv, Integer ul) throws AppException {
+		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_aspirate.toInt(), llfrpm, llftpos, pumpv, ul);
+		canBusService.waitForMod(MId.PipetteMod, overtime);
+	}
+
+	@ExtApiFn(name = "分液", order = FnOrder.pipetteDistribu)
+	public void pipetteDistribu(Integer llfrpm, Integer pumpv, Integer ul) throws AppException {
+		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_distribu.toInt(), llfrpm, pumpv, ul);
+		canBusService.waitForMod(MId.PipetteMod, overtime);
+	}
+
+	@ExtApiFn(name = "振荡", order = FnOrder.pipetteShakeUp)
+	public void pipetteShakeUp(Integer llfrpm, Integer maxzpos, Integer pumpv, Integer ul, Integer times) throws AppException {
+		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_shake_up.toInt(), llfrpm, maxzpos, pumpv, ul, times);
+		canBusService.waitForMod(MId.PipetteMod, overtime);
+	}
+	//pipette_clear_hanging_liquid
+
+	@ExtApiFn(name = "清除悬液", order = FnOrder.pipetteClearHangingLiquid)
+	public void pipetteClearHangingLiquid(Integer repeatTimes) throws AppException {
+		canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_clear_hanging_liquid.toInt(), repeatTimes);
+		canBusService.waitForMod(MId.PipetteMod, overtime);
+	}
+
+
 	public Boolean zAixsZeroPointIsTrigger() throws AppException {
 		return canBusService.callcmd(MId.PipetteMod.toInt(), CmdId.pipette_zmotor_read_zero_point_state.toInt()).getContentI32(0) == 1;
 	}

src/main/java/a8k/service/bases/FrontEndEventRouter.java

@@ -1,6 +1,11 @@
 package a8k.service.bases;
 
+import a8k.factory.ZAppPromoptFactory;
+import a8k.service.app.appctrl.mainflowctrl.base.AppActionErrorContext;
 import a8k.service.bases.appevent.*;
+import a8k.type.ecode.AppError;
+import a8k.type.ui.ZAppPromopt;
+import a8k.type.ui.ZAppPromoptType;
 import jakarta.annotation.PostConstruct;
 import jakarta.annotation.Resource;
 import lombok.extern.slf4j.Slf4j;
@@ -30,18 +35,44 @@ public class FrontEndEventRouter {
 	// Internal APIs
 	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
-	/**
-	 * 过滤事件
-	 * @param event 事件
-	 * @return 是否过滤
+
+	AppEvent preProcessAppEvent(AppEvent event) {
+		/*
+		 *	下面事件，直接转发给前端,前端需要处理
+		 */
+		if (event instanceof AppIDCardMountEvent) {
+			return event;    //前端需要更新IDcard的状态，并弹窗，有新的IDcard插入，询问用户是否保存
+		} else if (event instanceof AppIDCardUnmountEvent) {
+			return event;    //前端需要更新IDcard的状态
+		} else if (event instanceof AppTubeholderSettingUpdateEvent) {
+			return event;//前端需要更新试管架设置
+		} else if (event instanceof DoA8kStepActionEvent) {
+			return event;    //前端需要更新步骤提示信息
+		}
+
+		/*
+		 *	下面事件，均转换成 AppPromptEvents
+		 */
+		else if (event instanceof A8kEcodeContextListPromptEvent e) {
+			return ZAppPromoptFactory.buildAppPromptEvents(e);
+		} else if (event instanceof A8kErrorsPromptEvent e) {
+			return ZAppPromoptFactory.buildAppPromptEvents(e);
+		} else if (event instanceof AppWarningNotifyEvent e) {
+			return new AppPromptEvents(List.of(ZAppPromoptFactory.buildAppPromopt(e.error)));
+		} else if (event instanceof AppPromptEvents) {
+			return event;    //前端需要显示提示信息
+		}
+
+		/*
+		 *	下面事件，不需要前端处理
 		 */
-	Boolean filterEvent(AppEvent event) {
-		if (event instanceof A8kHardwareReport) {
-			return true;
-		} else if (event instanceof A8kCanBusOnConnectEvent) {
-			return true;
+		else if (event instanceof A8kCanBusOnConnectEvent) {
+			return null; //过滤，前端不需要处理
+		} else if (event instanceof A8kHardwareReport) {
+			return null;//过滤，前端不需要处理
+		} else {
+			return null;
 		}
-		return false;
 	}
 
 	synchronized AppEvent pollAppEventFromQueue() {
@@ -53,10 +84,11 @@ public class FrontEndEventRouter {
 	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 	public void onAppEvent(AppEvent event) {
-		if (filterEvent(event)) {
+		AppEvent afProcessEvent = preProcessAppEvent(event);
+		if (afProcessEvent == null) {
 			return;
 		}
-		appEventQueue.add(event);
+		appEventQueue.add(afProcessEvent);
 	}
 
 	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

src/main/java/a8k/service/bases/appevent/A8kEcodeContextListPromptEvent.java

@@ -6,7 +6,7 @@ import a8k.utils.ZList;
 import java.util.List;
 
 public class A8kEcodeContextListPromptEvent extends AppEvent {
-	List<AppActionErrorContext> ecodeList;
+	public List<AppActionErrorContext> ecodeList;
 
 	public A8kEcodeContextListPromptEvent(List<AppActionErrorContext> ecodeList) {
 		super(A8kEcodeContextListPromptEvent.class.getSimpleName());

src/main/java/a8k/service/bases/appevent/AppPromptEvents.java

@@ -0,0 +1,16 @@
+package a8k.service.bases.appevent;
+
+import a8k.type.ui.ZAppPromopt;
+
+import java.util.List;
+
+public class AppPromptEvents extends AppEvent {
+
+	public List<ZAppPromopt> prompt;
+
+	public AppPromptEvents(List<ZAppPromopt> prompt) {
+		super(AppPromptEvents.class.getSimpleName());
+		this.prompt = prompt;
+	}
+
+}

src/main/java/a8k/service/bases/appevent/DoA8kStepActionEvent.java

@@ -1,13 +1,16 @@
 package a8k.service.bases.appevent;
 
+import a8k.i18n.Internationalization;
 import a8k.service.app.appctrl.mainflowctrl.base.A8kActionStepType;
 
 public class DoA8kStepActionEvent extends AppEvent {
 	public A8kActionStepType actionStep;
+	public String            actionStepName;
 
 	public DoA8kStepActionEvent(A8kActionStepType actionStep) {
 		super(DoA8kStepActionEvent.class.getSimpleName());
 		this.actionStep     = actionStep;
+		this.actionStepName = Internationalization.a8kActionStepTypeToDisplayStr(actionStep);
 	}
 
 	public String toString() {

src/main/java/a8k/service/test/VirtualDeviceSimulationTest.java

@@ -4,6 +4,7 @@ import a8k.SpringBootBeanUtil;
 import a8k.a8kproj.fakeproj.*;
 import a8k.extapi.utils.ExtApiFn;
 import a8k.extapi.utils.ExtApiTab;
+import a8k.factory.ZAppPromoptFactory;
 import a8k.hardware.type.a8kcanprotocol.A8kEcode;
 import a8k.hardware.type.a8kcanprotocol.CmdId;
 import a8k.hardware.type.a8kcanprotocol.MId;
@@ -21,14 +22,12 @@ import a8k.service.dao.type.a8kidcard.zenum.A8kResultUnit;
 import a8k.service.test.state.VirtualDevice;
 import a8k.type.ConsumableOneChRawResult;
 import a8k.type.ReactionResult;
-import a8k.type.ecode.AECodeError;
-import a8k.type.ecode.AppError;
-import a8k.type.ecode.AEConsumeNotEnoughError;
-import a8k.type.ecode.AEHardwareError;
+import a8k.type.ecode.*;
 import a8k.type.exception.AppException;
 import a8k.type.reaction_result_type.ReactionResultStatus;
 import a8k.type.type.A8kTubeHolderType;
 import a8k.type.type.BloodType;
+import a8k.type.ui.ZAppPromopt;
 import a8k.utils.A8kPacketBuilder;
 import a8k.utils.ZDateUtils;
 import jakarta.annotation.Resource;
@@ -245,13 +244,12 @@ public class VirtualDeviceSimulationTest {
 		eventBus.pushEvent(event);
 	}
 
-	@ExtApiFn(name = "A8kErrorPromptEvent", group = "虚拟事件", order = 402)
+	@ExtApiFn(name = "发送AppPromptEvents ", group = "虚拟事件", order = 402)
 	public void buildAndSendA8kErrorPromptEvent() {
-		A8kErrorsPromptEvent event = new A8kErrorsPromptEvent(new AEConsumeNotEnoughError("Hscrp"));
-		eventBus.pushEvent(event);
-		event = new A8kErrorsPromptEvent(new AECodeError("XXXX额外的错误说明XXXX"));
-		eventBus.pushEvent(event);
-		event = new A8kErrorsPromptEvent(new AEHardwareError(A8kEcode.LOW_ERROR_CHECKCODE_IS_ERROR, MId.HbotM, CmdId.step_motor_read_pos));
+		List<ZAppPromopt> prompt = new ArrayList<>();
+		prompt.add(ZAppPromoptFactory.buildAppPromopt(new AEConsumeNotEnoughError("Hscrp")));
+		prompt.add(ZAppPromoptFactory.buildAppPromopt(new AETubeError(A8kEcode.APPE_A8K_PROJ_ID_IS_EMPTY, 1)));
+		AppPromptEvents event = new AppPromptEvents(prompt);
 		eventBus.pushEvent(event);
 	}
 

src/main/java/a8k/type/appret/ApiRet.java

@@ -0,0 +1,56 @@
+package a8k.type.appret;
+
+import a8k.factory.ZAppPromoptFactory;
+import a8k.hardware.type.a8kcanprotocol.A8kEcode;
+import a8k.type.exception.AppException;
+import a8k.type.ui.ZAppPromopt;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import lombok.Getter;
+
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public class ApiRet<T> {
+	// 错误信息
+	public A8kEcode ecode = null;
+	public String   dataType;
+	public Object   data;
+
+	// 接口请求时间
+	@Getter
+	long timestamp;
+
+	public ApiRet() {
+		this.timestamp = System.currentTimeMillis();
+	}
+
+	public static <T> ApiRet<T> success(T data) {
+		ApiRet<T> r = new ApiRet<>();
+		r.data  = data;
+		r.ecode = A8kEcode.SUC;
+		if (data != null)
+			r.dataType = data.getClass().getSimpleName();
+		return r;
+	}
+
+	public Boolean isSuccess() {
+		return ecode == A8kEcode.SUC || ecode == null;
+	}
+
+	public static ApiRet<Void> success() {
+		var ret = new ApiRet<Void>();
+		ret.ecode = A8kEcode.SUC;
+		return ret;
+	}
+
+	public static ApiRet<ZAppPromopt> fail(Exception e) {
+		ApiRet<ZAppPromopt> r = new ApiRet<>();
+		r.dataType = ZAppPromopt.class.getSimpleName();
+		r.data     = ZAppPromoptFactory.buildAppPromopt(e);
+
+		if (e instanceof AppException ex) {
+			r.ecode = ex.error.code;
+		} else {
+			r.ecode = A8kEcode.CODEERROR;
+		}
+		return r;
+	}
+}

src/main/java/a8k/type/appret/ApiV1Ret.java

@@ -1,71 +0,0 @@
-package a8k.type.appret;
-
-import a8k.hardware.type.a8kcanprotocol.A8kEcode;
-import a8k.type.ecode.AECodeError;
-import a8k.type.ecode.AppError;
-import a8k.type.exception.AppException;
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.fasterxml.jackson.annotation.JsonInclude;
-import io.swagger.v3.oas.annotations.media.Schema;
-import jakarta.validation.ValidationException;
-import lombok.Getter;
-import org.springframework.web.method.annotation.HandlerMethodValidationException;
-
-@JsonInclude(JsonInclude.Include.NON_NULL)
-public class ApiV1Ret<T> {
-	// 错误信息
-	@JsonIgnore
-	public String dataType;
-	public T      data;
-
-	// 接口请求时间
-	@Getter
-	long timestamp;
-
-	public ApiV1Ret() {
-		this.timestamp = System.currentTimeMillis();
-	}
-
-	public Boolean isSuccess() {
-		return !(data instanceof AppError);
-	}
-
-	//
-	//		builder
-	//
-
-	public static <T> ApiV1Ret<T> success(T object) {
-		ApiV1Ret<T> r = new ApiV1Ret<>();
-		r.data = object;
-		if (object != null)
-			r.dataType = object.getClass().getSimpleName();
-		return r;
-	}
-
-	public static ApiV1Ret<Void> success() {
-		return new ApiV1Ret<>();
-	}
-
-	public static <T> ApiV1Ret<T> fail(T error) {
-		ApiV1Ret<T> r = new ApiV1Ret<>();
-		r.data     = error;
-		r.dataType = error.getClass().getSimpleName();
-		return r;
-	}
-
-	public static ApiV1Ret<AppError> fail(Exception e) {
-		ApiV1Ret<AppError> r = new ApiV1Ret<>();
-		if (e instanceof AppException hexcep) {
-			r.data = hexcep.error;
-		} else if (e instanceof ValidationException ex) {
-			r.data = new AECodeError( ex.getLocalizedMessage());
-		} else if (e instanceof HandlerMethodValidationException validationE) {
-			r.data = new AECodeError(validationE.getMessage());
-		} else {
-			r.data = new AECodeError(e.getMessage());
-		}
-		r.dataType = r.data.getClass().getSimpleName();
-		return r;
-	}
-
-}

src/main/java/a8k/type/ui/ZAppErrorStackInfo.java

@@ -0,0 +1,7 @@
+package a8k.type.ui;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+
+public class ZAppErrorStackInfo {
+	public String[] stackTraceElements;
+}

src/main/java/a8k/type/ui/ZAppPromopt.java

@@ -0,0 +1,21 @@
+package a8k.type.ui;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+
+public class ZAppPromopt implements Serializable {
+	@Schema(description = "弹窗类型")
+	public ZAppPromoptType type;
+
+	@Schema(description = "主信息")
+	public String info;
+
+	@Schema(description = "详细信息")
+	public List<ZAppPromoptDetailInfo> detailInfos = new ArrayList<>();
+
+	@Schema(description = "异常栈信息")
+	public ZAppErrorStackInfo stackInfo;
+}

src/main/java/a8k/type/ui/ZAppPromoptDetailInfo.java

@@ -0,0 +1,11 @@
+package a8k.type.ui;
+
+public class ZAppPromoptDetailInfo {
+	public String name;
+	public String description;
+
+	public ZAppPromoptDetailInfo(String name, String description) {
+		this.name        = name;
+		this.description = description;
+	}
+}

src/main/java/a8k/type/ui/ZAppPromoptType.java

@@ -0,0 +1,8 @@
+package a8k.type.ui;
+
+public enum ZAppPromoptType {
+	Notify, //通知
+	Warn,   //警告
+	Error,  //错误
+	Fatal,  //致命错误
+}