package logic import ( "context" "encoding/json" "errors" "fmt" "strings" "time" "bj_power_mes/ent" "bj_power_mes/ent/agvpoint" "bj_power_mes/ent/agvtask" "bj_power_mes/ent/agvvehiclestate" "bj_power_mes/ent/dock" "bj_power_mes/ent/materialrequest" "bj_power_mes/internal/agv" "github.com/google/uuid" ) // ============ AGV 调度(2026-10-14 由 WMS 迁至 MES 为唯一真源) ============ // MES 持有海康 RCS 客户端与 agv_tasks 表;仓库完成备料(CompleteCall)后由 MES 触发派车。 // WMS 仅作为 UI 代理(/api/internal/agv/*)转发到本逻辑。 // AgvSubmitRow 下发 AGV 的一行(与 WMS 端 agvSubmitRow 字段一致,便于透明代理)。 type AgvSubmitRow struct { RequestNo string `json:"requestNo"` MaterialCode string `json:"materialCode"` MaterialName string `json:"materialName"` Unit string `json:"unit"` Qty float64 `json:"qty"` TargetDock string `json:"targetDock"` } // AgvSubmitRequest 手动下发 AGV(WMS「下发AGV」页 / MES UI)。 type AgvSubmitRequest struct { Rows []AgvSubmitRow `json:"rows"` SourceDock string `json:"sourceDock"` ConfirmForcePick string `json:"confirmForcePick"` // "1"=人工已确认强提风险点位,允许下发 } // SubmitAgv 手动下发 AGV:按 target_dock 聚合生成任务并调 RCS。 // AgvPointView AGV 点位视图(camelCase,与前端契约一致)。 type AgvPointView struct { ID int `json:"id"` PositionCode string `json:"positionCode"` Name string `json:"name"` IsDock bool `json:"isDock"` DockID *int `json:"dockId"` DockCode string `json:"dockCode"` HasPallet bool `json:"hasPallet"` Enabled bool `json:"enabled"` Locked bool `json:"locked"` // 派车锁(system=任务占用 / manual=人工锁定) LockedBy string `json:"lockedBy"` // system / manual LockedReason string `json:"lockedReason"` // 任务号或人工原因 LockedAt int64 `json:"lockedAt"` ForcePick bool `json:"forcePick"` // 强提风险标记(派车需人工二次确认) ForcePickAt int64 `json:"forcePickAt"` CreatedAt int64 `json:"createdAt"` } // SubmitAgv 手动下发 AGV(2026-11-06 拍板:客户要求的人工多段任务): // 每个目标点位生成一条「手动链」的起始段(kind=MANUAL,chain_no=本段 taskNo),第一段不指定车 // 由 RCS 自由派车;AGV 到位后页面显示分车结果,用户逐节点「下一个节点」(全程锁同一台车)/ // 「结束任务」推进,段数不确定。防撞强校验:接驳台点位有托盘 → 拒派;纯点位由前端二次确认后放行。 // 返回:创建段数、失败目标、链号列表(前端据此展示任务进行中面板)。 func (s *Service) SubmitAgv(ctx context.Context, req AgvSubmitRequest, operator string) (int, []string, []string, error) { if len(req.Rows) == 0 { return 0, nil, nil, errors.New("请至少选择一批待发料") } source := req.SourceDock if source == "" { source = "JBT21" // T7(2026-11-03 拍板):库房接驳台统一 JBT21 } // 目标字段复用语义为 AGV 点位编码(position_code) groups := map[string][]AgvSubmitRow{} for _, row := range req.Rows { if row.TargetDock == "" { continue } groups[row.TargetDock] = append(groups[row.TargetDock], row) } if len(groups) == 0 { return 0, nil, nil, errors.New("所选料行缺少目标点位(targetDock)") } // 解析点位:硬件映射 + 防撞强校验(接驳台点位有托盘拒派)+ 举升标记(模板推导用) type resolved struct { phys string // 送往 RCS 的物理目标(接驳台点位=dockCode;纯点位=position_code) lift bool // 是否接驳台点位(is_dock=true → 举升模板) } resolvedMap := map[string]resolved{} var collide, unknown []string for target := range groups { pt, err := s.ctx.EntClient.AgvPoint.Query().Where(agvpoint.PositionCode(target)).Only(ctx) if err != nil || pt == nil { unknown = append(unknown, target) continue } if !pt.Enabled { // 点位已停用(管理员在「产线管理」禁用)→ 硬拒:停用即「AGV 不去这个点」,不提供二次确认放行 collide = append(collide, target) continue } if pt.IsDock && pt.DockID != nil { d, derr := s.ctx.EntClient.Dock.Get(ctx, *pt.DockID) if derr != nil || d == nil { unknown = append(unknown, target) continue } if d.Status == "DISABLED" { collide = append(collide, target) // 停用接驳台禁派(2026-11-03 断头路补全):同防撞口径拒派 continue } if d.HasPallet { collide = append(collide, target) // 防撞拒派:接驳台有托盘 continue } // 模板按点位码硬编码(2026-11-14 用户终版):JBT21/GW* → B01 举升,虚拟点位 → B02 移动; // 历史 DOCK* 业务点位沿用库内 is_dock 兜底,不改存量派车行为。 lift := pt.IsDock switch AgvTemplateOf(target) { case "B01": lift = true case "B02": lift = false } resolvedMap[target] = resolved{phys: d.DockCode, lift: lift} } else { lift := pt.IsDock switch AgvTemplateOf(target) { case "B01": lift = true case "B02": lift = false } resolvedMap[target] = resolved{phys: pt.PositionCode, lift: lift} } } if len(unknown) > 0 { return 0, unknown, nil, fmt.Errorf("目标点位不存在:%s", strings.Join(unknown, "、")) } if len(collide) > 0 { return 0, collide, nil, fmt.Errorf("目标接驳台有托盘或已停用,存在碰撞/失效风险,禁止派车:%s(请在「产线管理」清空托盘或恢复启用后重试)", strings.Join(collide, "、")) } created := 0 failed := []string{} chainNos := []string{} submitErrs := []string{} for target, rows := range groups { r, ok := resolvedMap[target] if !ok { failed = append(failed, target) continue } // 模板只看目标点(2026-11-13 拍板):目标点有接驳台 → B01 举升;无接驳台 → B02 移动。 // 实际模板编号从「基础设置」sys_config 读取,页面配置在业务派车路径同样生效(不落回 yaml 硬编码); // tmpl 只作为库内 template_type 展示/重试判定,submitTmpl 才是送给 RCS 的 taskTyp。 tmpl := "NONE" if r.lift { tmpl = "LIFT" } submitTmpl := s.CfgStr(ctx, CfgAgvTaskTypPlain, "B02") if r.lift { submitTmpl = s.CfgStr(ctx, CfgAgvTaskTypLift, "B01") } // 2026-11-06 派车锁 + 强提标记检查(手动链入口同样受约束) if err := s.preDispatchPointCheck(ctx, target, req.ConfirmForcePick); err != nil { failed = append(failed, target) submitErrs = append(submitErrs, target+": "+err.Error()) s.ctx.EventLog.Write(ctx, "agv.dispatch_reject", operator, "", "agv_point", target, err.Error(), nil) continue } taskNo := "AGV" + strings.ToUpper(uuid.NewString()[:10]) chainNo := taskNo // 手动链:起始段 taskNo 即链号,后续段全部挂同一链号 mats, _ := json.Marshal(rows) t, err := s.ctx.EntClient.AgvTask.Create(). SetTaskNo(taskNo). SetSourceDock(source). SetTargetDock(r.phys). SetMaterialsJSON(string(mats)). SetStatus("PENDING"). SetKind("MANUAL"). SetBizType("CALL"). SetChainNo(chainNo). SetTemplateType(tmpl). SetOperator(operator). SetDispatchedAt(0). SetArrivedAt(0).Save(ctx) if err != nil { failed = append(failed, target) continue } // 第一段不指定车(用户拍板):RCS 自由派车,到位后回写 agv_code 作为本链锁定车 if _, aerr := s.ctx.Agv.SubmitTask(ctx, taskNo, source, r.phys, "", submitTmpl, ""); aerr != nil { s.agvRcsCommFail(ctx, "下发 "+source+"→"+r.phys, aerr) s.ctx.EntClient.AgvTask.UpdateOneID(t.ID). SetStatus("FAILED").SetRemark("RCS下发失败: " + aerr.Error()).Exec(ctx) failed = append(failed, target) continue } else { s.ctx.EntClient.AgvTask.UpdateOneID(t.ID). SetStatus("1"). SetDispatchedAt(time.Now().Unix()).Exec(ctx) } // 派车成功:目标点位置系统锁;强提点位确认后自动清标(手动链第一段同样受锁/强提约束) s.lockAgvPointForTask(ctx, r.phys, taskNo) s.clearForcePickOnDispatch(ctx, r.phys) s.ctx.EventLog.Write(ctx, "agv.dispatch", "", operator, "agv_task", taskNo, "手动多段任务起始段 "+source+"→"+r.phys+" 链="+chainNo, map[string]any{"rows": len(rows)}) chainNos = append(chainNos, chainNo) created++ } // 全部被拒(锁占用/强提未确认等)→ 返回具体原因给前端弹窗;部分成功只记事件日志(避免重复派车) if created == 0 && len(submitErrs) > 0 { return 0, failed, nil, errors.New(strings.Join(submitErrs, ";")) } return created, failed, chainNos, nil } // ListAgvPoints 列出 AGV 点位(enabledOnly=true 仅返回启用项,供派车下拉)。 func (s *Service) ListAgvPoints(ctx context.Context, enabledOnly bool) ([]AgvPointView, error) { q := s.ctx.EntClient.AgvPoint.Query() if enabledOnly { q = q.Where(agvpoint.Enabled(true)) } pts, err := q.Order(agvpoint.ByPositionCode()).All(ctx) if err != nil { return nil, err } docks, _ := s.ctx.EntClient.Dock.Query().All(ctx) dockCodeByID := map[int]string{} dockHasPallet := map[int]bool{} for _, d := range docks { dockCodeByID[d.ID] = d.DockCode dockHasPallet[d.ID] = d.HasPallet } out := make([]AgvPointView, 0, len(pts)) for _, p := range pts { v := AgvPointView{ ID: p.ID, PositionCode: p.PositionCode, Name: p.Name, IsDock: p.IsDock, DockID: p.DockID, Enabled: p.Enabled, CreatedAt: p.CreatedAt.Unix(), Locked: p.Locked, LockedBy: p.LockedBy, LockedReason: p.LockedReason, LockedAt: p.LockedAt, ForcePick: p.ForcePick, ForcePickAt: p.ForcePickAt, } if p.DockID != nil { v.DockCode = dockCodeByID[*p.DockID] v.HasPallet = dockHasPallet[*p.DockID] } out = append(out, v) } return out, nil } // UpdateAgvPoint 仅允许改 name 与 enabled(硬件映射 position_code/dock_id 不可改)。 func (s *Service) UpdateAgvPoint(ctx context.Context, id int, name string, enabled bool) error { _, err := s.ctx.EntClient.AgvPoint.UpdateOneID(id). SetName(name).SetEnabled(enabled).Save(ctx) return err } // DispatchCallAgv 库管人工派车(2026-11-03 定论:废除「备料完成自动派车」): // 库管在 WMS 叫料队列对已发货(SHIPPED)的叫料单点「送货」→ 下发「空车前往装货点」段(GO_LOAD)。 // 防重:同一叫料单存在未终态 GO_LOAD 段时拒绝重复派车。 func (s *Service) DispatchCallAgv(ctx context.Context, requestNo, operator string) error { mr, err := s.ctx.EntClient.MaterialRequest.Query(). Where(materialrequest.RequestNo(requestNo)).Only(ctx) if err != nil || mr == nil { return errors.New("叫料单不存在") } if mr.Status != "SHIPPED" { return errors.New("仅已发货的叫料单可派车(请先完成备料)") } if !mr.NeedAgv || mr.TargetDock == "" { return errors.New("该叫料单无需 AGV 配送") } exist, _ := s.ctx.EntClient.AgvTask.Query(). Where(agvtask.BizNo(requestNo), agvtask.KindEQ("GO_LOAD"), agvtask.StatusNotIn("9", "5", "FAILED")).Count(ctx) if exist > 0 { return errors.New("该叫料单已派车(存在执行中的空车段),请勿重复派车") } return s.DispatchAgvForCall(ctx, mr, operator) } // agvRcsCommFail AGV↔RCS 通讯失败统一落预警(2026-11-16): // 下发/查询/取消任一环节传输失败都算通讯异常,落「agv_rcs_fail」预警(10 分钟窗口去重防轮询风暴)。 // target 固定 "AGV"(预警中心按对象归集);best-effort,落预警失败仅打日志不阻断主流程。 func (s *Service) agvRcsCommFail(ctx context.Context, where string, err error) { _, aerr := s.CreateAlertDedup(ctx, "agv_rcs_fail", "警告", "AGV", "AGV 调度系统(RCS)通讯失败【"+where+"】:"+err.Error()+",请检查 RCS 服务与网络。", 10) if aerr != nil { fmt.Println("AGV 通讯失败落预警异常:", aerr) } } // DispatchAgvForCall 业务配送单派车(2026-11-13 拍板:独立「手动派车/叫料派车」入口下线, // 只由仓库备料完成等业务配送链路触发;前端不再有可直调的手动派车路由): // 由库管在 WMS 叫料队列点「送货」(DispatchCallAgv)调用——生成「空车前往装货点(JBT21)」段 // (kind=GO_LOAD)并下发。AGV 到位后 status=ARRIVED(到位待令),库管点「确认装车并送货」 // 才生成重载运输段(TRANSPORT)发往工位接驳台;卸货点再经「卸货完成并放行」后空车回充。 // 失败仅记日志/预警(best-effort),不阻断调用方响应。 func (s *Service) DispatchAgvForCall(ctx context.Context, mr *ent.MaterialRequest, operator string) error { if mr == nil || !mr.NeedAgv || mr.TargetDock == "" { return nil } // 装货点=库房接驳台 JBT21;停用禁派(按派车失败口径落预警,由人工改派或恢复接驳台)。 if d, derr := s.ctx.EntClient.Dock.Query().Where(dock.DockCodeEQ(dockStoreCode)).First(ctx); derr == nil && d != nil && d.Status == "DISABLED" { err := fmt.Errorf("库房接驳台 %s 已停用,自动派车拒绝(请恢复接驳台或人工配送)", dockStoreCode) if alertErr := s.CreateAlert(ctx, "agv_dispatch_fail", "警告", mr.RequestNo, "叫料单 "+mr.RequestNo+" AGV 派车失败:"+err.Error()); alertErr != nil { fmt.Println("AGV 派车失败落预警异常:", alertErr) } return err } row := AgvSubmitRow{ RequestNo: mr.RequestNo, MaterialCode: mr.MaterialCode, MaterialName: mr.MaterialName, Unit: mr.Unit, Qty: mr.SentQty, TargetDock: mr.TargetDock, } // 空车去程段:source 为空 = 单点 path,RCS 派最近空闲车前往装货点(业务自动触发,免人工确认)。 // 装货点应有托盘(库管完成备料时已写 hasPallet=true)——传感器与台账相互认证(软校验落预警)。 s.checkSensorVsLedger(ctx, dockStoreCode, true, mr.RequestNo) taskNo, err := s.dispatchAgvSegment(ctx, agvSegInput{ Kind: "GO_LOAD", BizType: "CALL", BizNo: mr.RequestNo, Source: "", Target: dockStoreCode, Materials: []AgvSubmitRow{row}, Operator: operator, }) if err != nil { if alertErr := s.CreateAlert(ctx, "agv_dispatch_fail", "警告", mr.RequestNo, "叫料单 "+mr.RequestNo+" AGV 空车派发失败(前往装货点):"+err.Error()); alertErr != nil { fmt.Println("AGV 派车失败落预警异常:", alertErr) } return err } // 派车成功:回写 AGV 链首任务号到叫料单(agv_task_no,与 AGV 任务互查) _ = s.ctx.EntClient.MaterialRequest.UpdateOneID(mr.ID).SetAgvTaskNo(taskNo).Exec(ctx) return nil } // AgvTaskView AGV 任务 camelCase 视图(与 WMS Agv.vue / MES 前端契约一致)。 // 注意:ent 生成的 AgvTask 因本项目 agv_task schema 字段名为 snake_case 而发射 snake_case JSON, // 但全项目接口 JSON 统一 camelCase(见《技术约束.md》),故此处显式映射,不影响其它实体契约。 type AgvTaskView struct { ID int `json:"id"` TaskNo string `json:"taskNo"` SourceDock string `json:"sourceDock"` TargetDock string `json:"targetDock"` MaterialsJSON string `json:"materialsJson"` RelatedRequestNo string `json:"relatedRequestNo"` RelatedOutboundNo string `json:"relatedOutboundNo"` Status string `json:"status"` Kind string `json:"kind"` BizType string `json:"bizType"` BizNo string `json:"bizNo"` ChainNo string `json:"chainNo"` AutoEnd bool `json:"autoEnd"` TemplateType string `json:"templateType"` AgvCode string `json:"agvCode"` Operator string `json:"operator"` DispatchedAt int64 `json:"dispatchedAt"` ArrivedAt int64 `json:"arrivedAt"` Remark string `json:"remark"` CreatedAt int64 `json:"createdAt"` } // toAgvTaskView 将 ent.AgvTask 映射为 camelCase 视图(供前端;materialsJson 保持原串由前端 JSON.parse)。 func toAgvTaskView(t *ent.AgvTask) AgvTaskView { return AgvTaskView{ ID: t.ID, TaskNo: t.TaskNo, SourceDock: t.SourceDock, TargetDock: t.TargetDock, MaterialsJSON: t.MaterialsJSON, RelatedRequestNo: t.RelatedRequestNo, RelatedOutboundNo: t.RelatedOutboundNo, Status: t.Status, Kind: t.Kind, BizType: t.BizType, BizNo: t.BizNo, ChainNo: t.ChainNo, AutoEnd: t.AutoEnd, TemplateType: t.TemplateType, AgvCode: t.AgvCode, Operator: t.Operator, DispatchedAt: t.DispatchedAt, ArrivedAt: t.ArrivedAt, Remark: t.Remark, CreatedAt: t.CreatedAt, } } // ListAgvVehicles 只读获取车辆状态(3.1.7 queryAgvStatus),供前端展示闲忙/充电/电量/位置。 // 纯只读:调度完全交给 RCS 自身,本系统不干预。Mock 模式返回示例车。 func (s *Service) ListAgvVehicles(ctx context.Context) ([]agv.AgvVehicle, error) { if s.ctx.Agv == nil || s.ctx.Agv.Disable() { // Mock:返回示例(避免前端在模拟模式下报错;真实模式由 RCS 提供) return s.ctx.Agv.QueryAgvStatus(ctx) } return s.ctx.Agv.QueryAgvStatus(ctx) } // ListAgvTasks 查询 AGV 任务(分页;与 WMS Agv.vue 契约保持 {list,total,page,pageSize})。 func (s *Service) ListAgvTasks(ctx context.Context, status, targetDock string, page, size int) (map[string]any, error) { query := s.ctx.EntClient.AgvTask.Query() if status != "" { query = query.Where(agvtask.Status(status)) } if targetDock != "" { query = query.Where(agvtask.TargetDock(targetDock)) } total, err := query.Clone().Count(ctx) if err != nil { return nil, err } if size < 1 || size > 200 { size = 20 } rows, err := query. Order(ent.Desc(agvtask.FieldCreatedAt)). Offset((page - 1) * size).Limit(size).All(ctx) if err != nil { return nil, err } list := make([]AgvTaskView, 0, len(rows)) for _, t := range rows { list = append(list, toAgvTaskView(t)) } return map[string]any{ "list": list, "total": total, "page": page, "pageSize": size, }, nil } // RefreshAgvTasks 拉取海康 RCS 更新未终态任务状态(由「刷新状态」按钮 / RCS 回调事件触发,无独立定时器)。 // 2026-11-14 用户定案:删除「传感器自动放行」——原 CALL 链要求配送单 DONE 才自动放行,而 DONE 又只能 // 由放行回写产生,构成死锁。放行只依靠明确的物理动作或指定端点的人工按钮; // 工位专用接驳台取货不需要任何工位侧确认。 func (s *Service) RefreshAgvTasks(ctx context.Context) (int, error) { list, err := s.ctx.EntClient.AgvTask.Query(). Where( agvtask.StatusIn("1", "2"), ).All(ctx) if err != nil { return 0, err } changed := 0 for _, t := range list { st, agvCode, qerr := s.ctx.Agv.QueryTask(ctx, t.TaskNo) if qerr != nil { // 2026-11-16:查询失败不再静默,落通讯预警(去重窗口防轮询风暴) s.agvRcsCommFail(ctx, "查询任务 "+t.TaskNo, qerr) continue } // 工位专用接驳台取货:GO_LOAD 到工位后直接装车并送回库房,工位侧零确认。 // 用户定案「工位的接驳台是专用的,不需要点确认」;库房端点仍保留人工装车/卸货确认。 if st == "9" && t.Kind == "GO_LOAD" && s.isLineDock(ctx, t.TargetDock) { if aerr := s.autoLoadAtLineDock(ctx, t, agvCode); aerr == nil { changed++ continue } else { s.ctx.EventLog.Write(ctx, "agv.line_auto_load_failed", "system", "", "agv_task", t.TaskNo, "工位接驳台自动取货未成功("+aerr.Error()+"),转人工确认", nil) } } upd := s.ctx.EntClient.AgvTask.UpdateOneID(t.ID) // 2026-11-04 载货台账绑定:RCS 分车后回写 agv_code(空则跳过,不改既有值) if agvCode != "" && agvCode != t.AgvCode { upd.SetAgvCode(agvCode) } switch st { case "9": // 已结束(到位) // 空车回充段(auto_end)直接结束;其余段进 ARRIVED「到位待令」由指定端点人工确认。 if t.AutoEnd { upd.SetStatus("9").SetArrivedAt(time.Now().Unix()) } else { upd.SetStatus("ARRIVED").SetArrivedAt(time.Now().Unix()) s.ctx.EventLog.Write(ctx, "agv.arrive", "", "", "agv_task", t.TaskNo, "AGV已到位,等待确认 "+t.TargetDock, nil) } case "5": // 取消完成 upd.SetStatus("5") default: // 1 已创建 / 2 执行中 upd.SetStatus(st) } if err := upd.Exec(ctx); err == nil { changed++ } } return changed, nil } // isLineDock 判断目标编码是否为产线(工位)接驳台;库房接驳台 JBT21 与虚拟点位均返回 false。 func (s *Service) isLineDock(ctx context.Context, code string) bool { if code == "" { return false } d, err := s.ctx.EntClient.Dock.Query().Where(dock.DockCodeEQ(code)).First(ctx) return err == nil && d != nil && d.DockType == "line" } // autoLoadAtLineDock 工位专用接驳台自动取货(2026-11-14 用户定案): // GO_LOAD 段到达工位接驳台后不再进 ARRIVED,直接完成装车动作并生成送回库房 JBT21 的运输段。 // 工位侧零确认;库房端点的卸货放行仍由 MES「卸货完成并放行」人工按钮完成。 // 先下发运输段再落装车动作:下发失败时本段保持执行中,下次刷新自动重试,不会断链。 func (s *Service) autoLoadAtLineDock(ctx context.Context, t *ent.AgvTask, agvCode string) error { if free, reason := s.Jbt21Free(ctx); !free { return fmt.Errorf("库房接驳台 %s 暂无空位:%s", dockStoreCode, reason) } if _, derr := s.dispatchAgvSegment(ctx, agvSegInput{ Kind: "TRANSPORT", BizType: t.BizType, BizNo: t.BizNo, ChainNo: t.ChainNo, Source: t.TargetDock, Target: dockStoreCode, Operator: "system", }); derr != nil { return fmt.Errorf("回库运输段下发失败: %w", derr) } upd := s.ctx.EntClient.AgvTask.UpdateOneID(t.ID). SetStatus("9").SetArrivedAt(time.Now().Unix()) if agvCode != "" { upd.SetAgvCode(agvCode) } if err := upd.Exec(ctx); err != nil { return err } // 装车动作写库:工位台面清空、该车置「有托盘」 s.setDockPalletByCode(ctx, t.TargetDock, false, "", chainRefOf(t)) s.setAgvLoadedState(ctx, agvCode, true, "AUTO_LOAD", "工位专用接驳台自动取货") // 车驶离工位 → 释放该点系统锁 s.unlockAgvPointByTask(ctx, t.TargetDock, t.TaskNo) s.ctx.EventLog.Write(ctx, "agv.line_dock_auto_load", "system", "", "agv_task", t.TaskNo, "工位接驳台 "+t.TargetDock+" 专用取货:车到位即自动装车并送回 "+dockStoreCode+"(工位侧无需确认)", nil) return nil } // CancelAgvTask 取消 AGV 任务。已下发给 RCS(状态 1/2)的先通知 RCS-Lite 取消,再落本地状态 5。 func (s *Service) CancelAgvTask(ctx context.Context, taskNo, reason, operator string) error { t, err := s.ctx.EntClient.AgvTask.Query().Where(agvtask.TaskNo(taskNo)).First(ctx) if err != nil { return errors.New("AGV 任务不存在") } if t.Status == "9" || t.Status == "5" { return errors.New("任务已结束,无法取消") } // ARRIVED(到位待令):车已停在目标点,取消=本段废弃(无需通知 RCS),人工处置现场 if t.Status == "1" || t.Status == "2" { if cerr := s.ctx.Agv.CancelTask(ctx, t.TaskNo, reason); cerr != nil { return fmt.Errorf("RCS 取消失败: %w", cerr) } } // 取消=任务终止:释放目标点位系统锁(manual 锁不动;JBT21 例外同样由锁来源判断兜底) s.unlockAgvPointByTask(ctx, t.TargetDock, t.TaskNo) if err := s.ctx.EntClient.AgvTask.UpdateOneID(t.ID). SetStatus("5").SetRemark(reason).Exec(ctx); err != nil { return err } s.ctx.EventLog.Write(ctx, "agv.cancel", "", operator, "agv_task", t.TaskNo, "取消AGV搬运 "+t.SourceDock+"→"+t.TargetDock, map[string]any{"reason": reason}) return nil } // RetryAgvTask 重试失败/卡住的 AGV 任务:沿用原 taskNo/source/target 重新向 RCS 下发。 // 仅允许对 FAILED 与未成功下发的 PENDING 任务重试;已结束(9/5)不可重试;目标接驳台有托盘拒派。 func (s *Service) RetryAgvTask(ctx context.Context, taskNo, operator string) error { t, err := s.ctx.EntClient.AgvTask.Query().Where(agvtask.TaskNo(taskNo)).First(ctx) if err != nil { return errors.New("AGV 任务不存在") } if t.Status == "9" || t.Status == "5" { return errors.New("任务已结束,无法重试") } // 防撞强校验:目标接驳台点位有托盘/已停用 → 拒派(与手动派车一致) if t.TargetDock != "" { if pt, perr := s.ctx.EntClient.AgvPoint.Query().Where(agvpoint.PositionCode(t.TargetDock)).Only(ctx); perr == nil && pt != nil && pt.IsDock && pt.DockID != nil { if d, derr := s.ctx.EntClient.Dock.Get(ctx, *pt.DockID); derr == nil && d != nil { if d.HasPallet { return errors.New("目标接驳台有托盘,禁止重试派车") } if d.Status == "DISABLED" { return errors.New("目标接驳台已停用,禁止重试派车(请先在「产线管理」恢复启用)") } } } } // 模板按段重新推导(与首次下派同一唯一入口):重试=重新下发,模板永远跟着段走, // 不沿用任务行落库值,避免点位类型变化后用错模板 tmpl, terr := s.agvTemplateType(ctx, t.SourceDock, t.TargetDock) if terr != nil { return terr } // 模板编号优先取「基础设置」sys_config(B01/B02,保存即生效),未配置回退 yaml 默认值。 submitTmpl := tmpl if tmpl == "LIFT" { submitTmpl = s.CfgStr(ctx, CfgAgvTaskTypLift, "B01") } else { submitTmpl = s.CfgStr(ctx, CfgAgvTaskTypPlain, "B02") } // 指定车重试(同段同车):任务行已回写 agv_code 时沿用,未回写传空由 RCS 自由派 _, aerr := s.ctx.Agv.SubmitTask(ctx, taskNo, t.SourceDock, t.TargetDock, "", submitTmpl, t.AgvCode) if aerr != nil { s.agvRcsCommFail(ctx, "重试下发 "+t.SourceDock+"→"+t.TargetDock, aerr) s.ctx.EntClient.AgvTask.UpdateOneID(t.ID). SetStatus("FAILED").SetRemark("RCS重试下发失败: " + aerr.Error()).Exec(ctx) return fmt.Errorf("RCS 重试下发失败: %w", aerr) } s.ctx.EntClient.AgvTask.UpdateOneID(t.ID). SetStatus("1"). SetTemplateType(tmpl). SetDispatchedAt(time.Now().Unix()).SetRemark("").Exec(ctx) // 重试成功:重新锁定目标点位(失败期间锁可能已被取消路径释放) s.lockAgvPointForTask(ctx, t.TargetDock, taskNo) s.ctx.EventLog.Write(ctx, "agv.retry", "", operator, "agv_task", taskNo, "重试AGV搬运 "+t.SourceDock+"→"+t.TargetDock, nil) return nil } // AgvMode 返回 AGV 对接模式(mock / 真实 RCS),供前端提示当前是否在模拟。 func (s *Service) AgvMode() map[string]any { mock := s.ctx.Agv.Disable() tip := "" if mock { tip = "当前为模拟模式(未接真实海康 RCS-Lite):查询任务状态会立即标记为已结束,便于离线联调。现场对接请在配置中关闭 EnableMock 并填写 RCS-Lite 地址(BaseURL,默认端口 8182)。" } else { tip = "已对接真实海康 RCS-Lite。" } return map[string]any{"mock": mock, "tip": tip} } // ApplyAgvCallback RCS-Lite SPI 回调(文档 2.2.1 任务执行通知):按 taskCode 匹配任务,按 method 更新状态。 // method: start 任务开始 / outbin 走出储位 / end 任务结束 / cancel 任务单取消。 // RCS 数字状态:1 已创建 / 2 执行中 / 5 取消完成 / 9 已结束。 // robotCode(文档 2.2.1 必填 AGV 编号)用于绑定任务与载货台账(2026-11-04 载货状态补做)。 func (s *Service) ApplyAgvCallback(ctx context.Context, taskCode, method, robotCode string) error { if taskCode == "" { return errors.New("缺少 taskCode") } t, err := s.ctx.EntClient.AgvTask.Query(). Where(agvtask.TaskNo(taskCode)).Only(ctx) if err != nil || t == nil { return nil // 未知任务号(如 MOCK 或不匹配)静默忽略 } var status string arrived := false switch method { case "end": // 2026-11-03 三层机制:到位分流——空车回充段(auto_end)直接结束;其余进 ARRIVED 待人工确认 if t.AutoEnd { status = "9" } else { status = "ARRIVED" } arrived = true case "cancel": status = "5" case "start", "outbin", "": status = "2" default: status = "2" } upd := s.ctx.EntClient.AgvTask.UpdateOneID(t.ID).SetStatus(status) // 2026-11-04 载货台账绑定:回调携带 robotCode 时回写任务 agv_code if robotCode != "" && robotCode != t.AgvCode { upd.SetAgvCode(robotCode) } if arrived { upd.SetArrivedAt(time.Now().Unix()) } if err := upd.Exec(ctx); err != nil { return err } if arrived && status == "ARRIVED" { s.ctx.EventLog.Write(ctx, "agv.arrive", "", "", "agv_task", t.TaskNo, "AGV已到位(回调),等待人工确认 "+t.TargetDock, map[string]any{"method": method}) } return nil } // notifyDeliveredOnArrival AGV 到位 → 关联出库单回写「已送达」(2026-11-03 断头路补全: // 出库单状态机「已出库/已送达」此前无写者)。任务关联叫料单 → 叫料单上回写的 WMS 出库单号 // (可多个逗号分隔)→ 通知 WMS 置已送达。best-effort:WMS 不可达只记日志,不阻断到位链路。 func (s *Service) notifyDeliveredOnArrival(ctx context.Context, t *ent.AgvTask) { if t == nil || t.RelatedRequestNo == "" || s.ctx.Wms == nil { return } mr, mErr := s.ctx.EntClient.MaterialRequest.Query(). Where(materialrequest.RequestNo(t.RelatedRequestNo)).First(ctx) if mErr != nil || mr == nil || mr.OutboundNo == "" { return } nos := []string{} for _, p := range strings.Split(mr.OutboundNo, ",") { if p = strings.TrimSpace(p); p != "" { nos = append(nos, p) } } if len(nos) == 0 { return } if dErr := s.ctx.Wms.DeliveredOutbound(ctx, nos); dErr != nil { fmt.Println("出库单回写已送达失败(可忽略):", dErr) // WMS 侧本地回写失败返回 5xx 后,MES 调用方落 event_log 留痕; // 同时落台账供人工重试(best-effort,不阻断到位链路,不自动重试) s.ctx.EventLog.Write(ctx, "wms.delivered_outbound_failed", "", "system", "agv_task", t.TaskNo, "出库单已送达回写 WMS 失败:"+dErr.Error(), map[string]any{"outboundNos": nos}) s.recordSyncFailure("outbound.delivered", t.TaskNo, "/api/internal/outbound/delivered", map[string]any{"outboundNos": nos}, dErr) return } s.ctx.EventLog.Write(ctx, "outbound.delivered", "", "AGV", "agv_task", t.TaskNo, "AGV到位,出库单已回写「已送达」:"+mr.OutboundNo, nil) } // ============ 三段链引擎(2026-11-03 拍板「AGV 三层安全机制」核心) ============ // 第一层 业务自动触发(免弹窗):空车去程(GO_LOAD)/空车回充(EMPTY_RETURN)自动下发; // 第二层 装卸强制确认(到位待令):到位=ARRIVED,人工「确认装车并送货/卸货完成并放行」才走下一段; // 第三层 人工自由调度(FREE):每段人工发起,前端弹「请确保路径畅通无杂物」。 // 动作写库(传感器↔台账相互认证的事件驱动版,无轮询): // 确认装车(车背托盘离开装货点)→ 装货点 hasPallet=false;确认卸货(托盘上台)→ 卸货点 hasPallet=true。 const ( dockStoreCode = "JBT21" // 库房接驳台(装货点/空托盘回收终点;T7 2026-11-03 统一 JBT21) agvChargePoint = "AGV-CHARGE01" // 充电位(seed 纯点位,is_dock=false) ) // agvSegInput 单段任务入参 type agvSegInput struct { Kind string // GO_LOAD / TRANSPORT / EMPTY_RETURN / FREE / MANUAL BizType string // CALL / PALLET / FREE BizNo string ChainNo string // 空=新建链(取本段 taskNo) Source string // 空=空车单点 path(RCS 派最近空闲车) Target string Materials []AgvSubmitRow Operator string AutoEnd bool AgvCode string // 指定执行车辆(空=RCS 自由派车;手动多段链第二段起必须传,全程锁同一台车) // ConfirmForcePick 人工二次确认强提风险点位("1"=已确认;业务自动派车恒空 → 强提点位拒绝转人工) ConfirmForcePick string } // agvTemplateType 模板推导唯一入口(2026-11-14 用户终版改为【按点位码硬编码】): // // 目标点为 JBT21 或 GW*(工位接驳台)→ LIFT → B01 举升任务模板; // 目标点为 7 个虚拟点位(A1-A4 / XW / XT / KF1)→ NONE → B02 移动任务模板。 // 历史 DOCK* 业务点位不在 28 个点位内,按库内 is_dock 兜底,保证存量派车链路不被改动。 // // 规则真源 logic.AgvTemplateOf;举升模板编号仍取「基础设置」可配值(默认 B01/B02)。 // 原实现「起点或终点任一为接驳台就举升」已废止;模板内部动作序列由 RCS 预置,MES 不控制动作。 // 点位查询失败返回错误阻断下发(宁可不下发)。 func (s *Service) agvTemplateType(ctx context.Context, _ string, target string) (string, error) { // 保留 source 形参以兼容所有派车入口的调用签名;判定只看 target if target == "" { return "", fmt.Errorf("AGV 目标点位不能为空") } pt, err := s.ctx.EntClient.AgvPoint.Query().Where(agvpoint.PositionCode(target)).Only(ctx) if err != nil || pt == nil { return "", fmt.Errorf("AGV 点位不存在:%s", target) } switch AgvTemplateOf(target) { case "B01": return "LIFT", nil case "B02": return "NONE", nil default: // 历史 DOCK* 业务点位:沿用库内属性,不改存量派车行为 if pt.IsDock { return "LIFT", nil } return "NONE", nil } } // dispatchAgvSegment 创建一段任务并自动下发 RCS(业务触发统一走此口)。返回本段 taskNo。 func (s *Service) dispatchAgvSegment(ctx context.Context, in agvSegInput) (string, error) { if in.Target == "" { return "", fmt.Errorf("缺少目标点位") } // 2026-11-04 载货防撞硬拒(B3):AGV 载货=true 且 目标接驳台有托盘(台账/PLC 传感器)→ 拒派 if err := s.guardLoadedAgvVsTarget(ctx, in.Target); err != nil { return "", err } // 2026-11-06 派车锁 + 强提标记 + 传感器↔锁比对(统一入口,所有派车入口生效) if err := s.preDispatchPointCheck(ctx, in.Target, in.ConfirmForcePick); err != nil { return "", err } // 模板推导(集中唯一入口):段涉及接驳台 → 举升模板;随任务落库并映射 RCS taskTyp tmpl, terr := s.agvTemplateType(ctx, in.Source, in.Target) if terr != nil { return "", terr } taskNo := "AGV" + strings.ToUpper(uuid.NewString()[:10]) chain := in.ChainNo if chain == "" { chain = taskNo } mats, _ := json.Marshal(in.Materials) remark := "" if pt := s.agvPointByCode(ctx, in.Target); pt != nil && pt.ForcePick { remark = "[强提风险已人工确认]" } t, err := s.ctx.EntClient.AgvTask.Create(). SetTaskNo(taskNo). SetSourceDock(in.Source). SetTargetDock(in.Target). SetMaterialsJSON(string(mats)). SetRelatedRequestNo(in.BizNo). SetStatus("PENDING"). SetKind(in.Kind).SetBizType(in.BizType).SetBizNo(in.BizNo). SetChainNo(chain).SetAutoEnd(in.AutoEnd). SetTemplateType(tmpl). SetOperator(in.Operator). SetRemark(remark). SetDispatchedAt(0).SetArrivedAt(0).Save(ctx) if err != nil { return "", err } submitTmpl := tmpl if tmpl == "LIFT" { submitTmpl = s.CfgStr(ctx, CfgAgvTaskTypLift, "B01") } else { submitTmpl = s.CfgStr(ctx, CfgAgvTaskTypPlain, "B02") } _, aerr := s.ctx.Agv.SubmitTask(ctx, taskNo, in.Source, in.Target, "", submitTmpl, in.AgvCode) if aerr != nil { s.agvRcsCommFail(ctx, "下发 "+in.Source+"→"+in.Target, aerr) s.ctx.EntClient.AgvTask.UpdateOneID(t.ID). SetStatus("FAILED").SetRemark("RCS下发失败: " + aerr.Error()).Exec(ctx) return "", aerr } s.ctx.EntClient.AgvTask.UpdateOneID(t.ID). SetStatus("1"). SetDispatchedAt(time.Now().Unix()).Exec(ctx) // 派车成功:目标点位置系统锁(充电位免锁);强提点位人工确认派车成功后自动清标 s.lockAgvPointForTask(ctx, in.Target, taskNo) s.clearForcePickOnDispatch(ctx, in.Target) s.ctx.EventLog.Write(ctx, "agv.dispatch", "", in.Operator, "agv_task", taskNo, "下发AGV段任务["+in.Kind+"] "+in.Source+"→"+in.Target+" 链="+chain, nil) return taskNo, nil } // ConfirmLoadAndGo 确认装车并送货(ARRIVED + GO_LOAD):装货点托盘被 AGV 背走 → hasPallet=false; // 生成重载运输段(TRANSPORT)自动下发——nextDock 为空且链上关联叫料单时默认取叫料单目标接驳台。 // confirmForcePick="1" 表示库管已对强提风险目标点位完成人工二次确认。 // 业务口径(2026-11-14 拍板):库房装货点 JBT21 多台共用,仍由库管确认装车防拿错; // 工位专用接驳台取货已在 RefreshAgvTasks → autoLoadAtLineDock 自动完成,不会再进本确认流程。 func (s *Service) ConfirmLoadAndGo(ctx context.Context, taskNo, nextDock, operator, confirmForcePick string) error { t, err := s.loadArrivedTask(ctx, taskNo, "GO_LOAD") if err != nil { return err } if nextDock == "" && t.BizType == "CALL" && t.RelatedRequestNo != "" { if mr, merr := s.ctx.EntClient.MaterialRequest.Query(). Where(materialrequest.RequestNo(t.RelatedRequestNo)).First(ctx); merr == nil && mr != nil { nextDock = mr.TargetDock } } if nextDock == "" && t.BizType == "CALL" { // 配送单驱动(2026-11-05 拍板):BizNo=配送单号,目标接驳台随物料行下发 //(WMS 创建配送单时确定,可改终端期望接驳台) if rows := decodeSegMaterials(t.MaterialsJSON); len(rows) > 0 { nextDock = rows[0].TargetDock } } if nextDock == "" { return errors.New("请选择送货目标接驳台/点位") } // 运输目标防撞强校验(目标必须无托盘且启用) if err := s.guardTransportTarget(ctx, nextDock); err != nil { return err } // 装车动作写库:装货点托盘被背走 s.setDockPalletByCode(ctx, t.TargetDock, false, "", chainRefOf(t)) // 2026-11-04 载货台账(B1):取货确认 → 该车置「有托盘」 s.setAgvLoadedState(ctx, t.AgvCode, true, "AUTO_LOAD", operator) // 2026-11-06 派车锁:AGV 装货离场 → 装货点释放系统锁(JBT21 例外:不自动释放,库管手动解锁) if t.TargetDock != dockStoreCode { s.unlockAgvPointByTask(ctx, t.TargetDock, t.TaskNo) } // 本段结束 s.ctx.EntClient.AgvTask.UpdateOneID(t.ID).SetStatus("9").Exec(ctx) _, derr := s.dispatchAgvSegment(ctx, agvSegInput{ Kind: "TRANSPORT", BizType: t.BizType, BizNo: t.BizNo, ChainNo: t.ChainNo, Source: t.TargetDock, Target: nextDock, Materials: decodeSegMaterials(t.MaterialsJSON), Operator: operator, ConfirmForcePick: confirmForcePick, }) if derr != nil { return fmt.Errorf("运输段下发失败: %w", derr) } s.ctx.EventLog.Write(ctx, "agv.load_confirm", operator, "", "agv_task", taskNo, "确认装车并送货,运输段 "+t.TargetDock+"→"+nextDock, nil) return nil } // ConfirmUnloadRelease 卸货完成并放行(ARRIVED + TRANSPORT/FREE): // 卸货动作写库(卸货点 hasPallet=true);本段结束;自动生成空车回充段(免确认,到位自动结束)。 // 出库单「已送达」回写也移至此处(货真正卸下才算送达)。 func (s *Service) ConfirmUnloadRelease(ctx context.Context, taskNo, operator string) error { t, err := s.loadArrivedTask(ctx, taskNo, "TRANSPORT", "FREE") if err != nil { return err } // 卸货动作写库:托盘上台 s.setDockPalletByCode(ctx, t.TargetDock, true, chainRefOf(t), chainRefOf(t)) // 2026-11-04 载货台账(B1):卸货确认 → 该车置「空车」 s.setAgvLoadedState(ctx, t.AgvCode, false, "AUTO_UNLOAD", operator) // 2026-11-06 派车锁:卸货完成自动释放目标点位(JBT21 例外:不自动释放,库管手动解锁) if t.TargetDock != dockStoreCode { s.unlockAgvPointByTask(ctx, t.TargetDock, t.TaskNo) } s.ctx.EntClient.AgvTask.UpdateOneID(t.ID).SetStatus("9").Exec(ctx) // 出库单回写已送达(CALL 链) if t.BizType == "CALL" { s.notifyDeliveredOnArrival(ctx, t) // 配送单送达回写(2026-11-05 拍板):BizNo=配送单号 → WMS 置「已送达」; // 旧叫料单直派链路 BizNo=叫料单号,WMS 端查不到配送单时忽略。 if s.ctx.Wms != nil && t.RelatedRequestNo != "" { if derr := s.ctx.Wms.DeliveryDelivered(ctx, t.BizNo); derr != nil { fmt.Println("配送单送达回写失败(可人工改状态):", derr) s.recordSyncFailure("delivery.delivered", t.BizNo, "/api/internal/delivery/delivered", map[string]any{"deliveryNo": t.BizNo}, derr) } } } // 空车回充段:业务自动触发免确认,到位自动结束 if _, derr := s.dispatchAgvSegment(ctx, agvSegInput{ Kind: "EMPTY_RETURN", BizType: t.BizType, BizNo: t.BizNo, ChainNo: t.ChainNo, Source: t.TargetDock, Target: agvChargePoint, Operator: operator, AutoEnd: true, }); derr != nil { fmt.Println("空车回充段下发失败(可人工调度):", derr) // 本地动作失败(非跨系统通知):落预警中心 + 操作日志,不进同步失败台账 if aerr := s.CreateAlert(ctx, "agv_empty_return_fail", "警告", t.TaskNo, "AGV 任务 "+t.TaskNo+" 空车回充段下发失败:"+derr.Error()+"(请人工调度)"); aerr != nil { fmt.Println("空车回充失败落预警异常:", aerr) } s.ctx.EventLog.Write(ctx, "agv.empty_return_failed", "", "system", "agv_task", t.TaskNo, "空车回充段下发失败:"+derr.Error()+"(请人工调度)", nil) } s.ctx.EventLog.Write(ctx, "agv.unload_confirm", operator, "", "agv_task", taskNo, "卸货完成并放行,托盘落位 "+t.TargetDock+",空车自动回充", nil) // 事件驱动收口:检查有无 CLOSING 班次可置 CLOSED s.maybeCloseShifts(ctx) return nil } // FinishFreeReturn 单点「结束回充电位」(ARRIVED + FREE / 人工派车起始 MANUAL 段): // 本段结束,空车回充自动下发。人工派车完整生命周期走 AgvChainEndTask,这里兜底旧自由调度单段。 func (s *Service) FinishFreeReturn(ctx context.Context, taskNo, operator string) error { t, err := s.loadArrivedTask(ctx, taskNo, "FREE", "MANUAL") if err != nil { return err } s.ctx.EntClient.AgvTask.UpdateOneID(t.ID).SetStatus("9").Exec(ctx) // 派车锁:FREE 段收尾 → 目标点位释放(JBT21 例外不自动释放) if t.TargetDock != dockStoreCode { s.unlockAgvPointByTask(ctx, t.TargetDock, t.TaskNo) } if _, derr := s.dispatchAgvSegment(ctx, agvSegInput{ Kind: "EMPTY_RETURN", BizType: "FREE", BizNo: t.BizNo, ChainNo: t.ChainNo, Source: t.TargetDock, Target: agvChargePoint, Operator: operator, AutoEnd: true, }); derr != nil { return fmt.Errorf("回充段下发失败: %w", derr) } s.ctx.EventLog.Write(ctx, "agv.free_finish", operator, "", "agv_task", taskNo, "自由调度结束,AGV 回充电位", nil) return nil } // ============ 手动多段链(2026-11-06 拍板:SubmitAgv 逐节点人工推进,全程锁同一台车) ============ // 流程:第一段(kind=MANUAL,不指定车)RCS 自由派车 → 到位回写 agv_code 即本链锁定车 → // 用户「下一个节点」(链内每段都用锁定车下发,段数不确定)→ 用户「结束任务」(校验车无托盘, // 空车回充不指定车)。与业务三段链(GO_LOAD/TRANSPORT/EMPTY_RETURN 自动推进)互不干扰。 // AgvChainInfo 手动链视图(任务进行中面板)。 type AgvChainInfo struct { ChainNo string `json:"chainNo"` AgvCode string `json:"agvCode"` // 锁定车(最新回写的 agv_code;空=RCS 尚未分车) Active bool `json:"active"` // 是否进行中(最新段未终态) Segments []AgvTaskView `json:"segments"` // 已走节点(按段创建顺序) } // agvChainSegments 取链内全部段(按创建顺序);不存在返回空。 func (s *Service) agvChainSegments(ctx context.Context, chainNo string) []*ent.AgvTask { segs, err := s.ctx.EntClient.AgvTask.Query(). Where(agvtask.ChainNo(chainNo)). Order(ent.Asc(agvtask.FieldID)). All(ctx) if err != nil { return nil } return segs } // agvChainCurrent 链内最新非终态段(9 已完成 / 5 已取消 视为终态);无则返回 nil。 func agvChainCurrent(segs []*ent.AgvTask) *ent.AgvTask { for i := len(segs) - 1; i >= 0; i-- { if segs[i].Status != "9" && segs[i].Status != "5" { return segs[i] } } return nil } // agvChainGuardManual 校验链存在且全部段为手动段(防止用链接口操作业务自动链)。 func agvChainGuardManual(segs []*ent.AgvTask) error { if len(segs) == 0 { return errors.New("任务链不存在") } for _, seg := range segs { if seg.Kind != "MANUAL" { return errors.New("该任务链不是手动逐节点任务,不支持本操作") } } return nil } // AgvChainNextNode 手动链「下一个节点」:当前段必须已到位(ARRIVED);取链锁定车 // (最新段 agv_code,未回写则拒绝)注入下发;当前段置 9,新段挂同一链号。 // source 空=沿用上一节点落点;target 必填(用户自选下一段去哪)。 // confirmForcePick="1" 表示用户已对强提风险目标点位完成人工二次确认。 func (s *Service) AgvChainNextNode(ctx context.Context, chainNo, source, target, operator, confirmForcePick string) (string, error) { if chainNo == "" { return "", errors.New("缺少任务链号") } if target == "" { return "", errors.New("请选择下一节点目标点位") } segs := s.agvChainSegments(ctx, chainNo) if err := agvChainGuardManual(segs); err != nil { return "", err } cur := agvChainCurrent(segs) if cur == nil { return "", errors.New("任务链已结束,不能加节点") } switch cur.Status { case "ARRIVED": // 到位待令,可走下一段 case "FAILED", "PENDING": return "", errors.New("上一节点未成功下发到 RCS,请先在「AGV任务」列表对该任务重试") default: // 1 已创建 / 2 执行中 return "", errors.New("AGV 尚未到位(当前节点执行中),到位后才能下发下一节点") } // 全程锁车:链锁定车=当前段已回写的 agv_code;RCS 未分车必须先刷新拿到车号 agvCode := cur.AgvCode if agvCode == "" { return "", errors.New("AGV 车辆信息尚未回写,请点「刷新状态」获取当前车辆后再下发下一节点") } // 目标防撞强校验(与手动派车同口径:接驳台有托盘/停用拒派) if err := s.guardTransportTarget(ctx, target); err != nil { return "", err } src := strings.TrimSpace(source) if src == "" { src = cur.TargetDock // 默认从上一节点落点出发 } // 本段走完(置 9)再下发下一段;失败回滚本段状态 s.ctx.EntClient.AgvTask.UpdateOneID(cur.ID).SetStatus("9").Exec(ctx) taskNo, derr := s.dispatchAgvSegment(ctx, agvSegInput{ Kind: "MANUAL", BizType: "CALL", ChainNo: chainNo, Source: src, Target: target, AgvCode: agvCode, Operator: operator, ConfirmForcePick: confirmForcePick, }) if derr != nil { s.ctx.EntClient.AgvTask.UpdateOneID(cur.ID).SetStatus("ARRIVED").Exec(ctx) return "", fmt.Errorf("下一节点下发失败: %w", derr) } // AGV 驶向下一节点 → 上一节点落点释放系统锁(JBT21 例外不自动释放) if cur.TargetDock != dockStoreCode { s.unlockAgvPointByTask(ctx, cur.TargetDock, cur.TaskNo) } s.ctx.EventLog.Write(ctx, "agv.chain_next", operator, "", "agv_task", taskNo, "手动链下一节点 "+src+"→"+target+"(锁车 "+agvCode+",链="+chainNo+")", nil) return taskNo, nil } // AgvChainEndTask 手动链「结束任务」:当前段必须已到位(ARRIVED);先校验 AGV 上无托盘 // (载货台账硬校验 + RCS 实时车载货架校验),通过后当前段置 9,下发空车回充段(不指定车)。 // force=人工确认无托盘强制结束:仅在 RCS 状态查询失败(超时/报错)时放行,操作留痕; // 台账判定有托盘时无论是否 force 一律拒绝(台账是系统权威,人工勾选不覆盖)。 func (s *Service) AgvChainEndTask(ctx context.Context, chainNo, operator string, force bool) error { if chainNo == "" { return errors.New("缺少任务链号") } segs := s.agvChainSegments(ctx, chainNo) if err := agvChainGuardManual(segs); err != nil { return err } cur := agvChainCurrent(segs) if cur == nil { return errors.New("任务链已结束") } if cur.Status != "ARRIVED" { return errors.New("AGV 尚未到位,到位后才能结束任务") } agvCode := cur.AgvCode if agvCode == "" { return errors.New("车辆编号尚未回写(RCS 未分车),请先点「刷新状态」后再结束任务") } // 无托盘校验①:载货台账(取货/卸货确认与人工维护写入) if st, serr := s.ctx.EntClient.AgvVehicleState.Query(). Where(agvvehiclestate.AgvCode(agvCode)).First(ctx); serr == nil && st != nil && st.HasPallet { return errors.New("请确认 AGV 上没有托盘后再结束任务(载货台账:该车有托盘,请先卸货或在「车辆状态」人工修正)") } // 无托盘校验②:RCS 实时车载货架编号(podCode 非空且非 "0" = 车上背着货)。 // RCS 查询失败(超时/报错)→ 默认拒绝结束;用户勾选「人工确认无托盘」可强制结束(留痕)。 vs, verr := s.ctx.Agv.QueryAgvStatus(ctx) if verr != nil && !force { return errors.New("RCS 状态查询失败,请稍后重试;如确认 AGV 上无托盘,可勾选「人工确认无托盘」强制结束") } if verr == nil { for _, v := range vs { if v.RobotCode == agvCode && v.PodCode != "" && v.PodCode != "0" { return errors.New("请确认 AGV 上没有托盘后再结束任务(RCS 上报车载货:" + v.PodCode + ",请先卸货)") } } } s.ctx.EntClient.AgvTask.UpdateOneID(cur.ID).SetStatus("9").Exec(ctx) // 结束任务:AGV 驶离当前落点回充 → 释放该点系统锁(JBT21 例外:保持锁定,库管手动解锁) if cur.TargetDock != dockStoreCode { s.unlockAgvPointByTask(ctx, cur.TargetDock, cur.TaskNo) } if _, derr := s.dispatchAgvSegment(ctx, agvSegInput{ Kind: "EMPTY_RETURN", BizType: "CALL", ChainNo: chainNo, Source: cur.TargetDock, Target: agvChargePoint, Operator: operator, AutoEnd: true, }); derr != nil { fmt.Println("手动链空车回充段下发失败(可人工调度):", derr) } endNote := "" if force { endNote = ",人工确认无托盘强制结束(RCS 查询失败)" } s.ctx.EventLog.Write(ctx, "agv.chain_end", operator, "", "agv_task", chainNo, "手动链任务结束(锁车 "+agvCode+")"+endNote+",空车自动回充", nil) return nil } // AgvChainForceEnd 手动链「强制结束」安全阀(2026-11-16 主控定案): // 用途=解开「AGV 未到位却无法结束、也无法继续」的系统死锁。当现场实物已人工处置 // (货已卸/车已停),但 RCS 状态未回、回调丢失或断网导致本地段卡在 1/2/FAILED 时, // 人工确认后调用。本方法【只清系统状态】:当前段置终态 9 + 释放目标点位系统锁 + 留痕; // 【绝不调用海康任何接口】——尤其不调 cancelTask(forceCancel=0 会把车上的货直接扔在路上, // 见《AGV海康litev1.5.md》§2.1.3)。下发空车回充也不做:现场车辆处置由人负责,系统不再遥控。 // 风险由前端确认弹窗明确告知,后端这里只保证本地状态机一致、不产生任何物理动作。 func (s *Service) AgvChainForceEnd(ctx context.Context, chainNo, operator, reason string) error { if chainNo == "" { return errors.New("缺少任务链号") } segs := s.agvChainSegments(ctx, chainNo) if err := agvChainGuardManual(segs); err != nil { return err } cur := agvChainCurrent(segs) if cur == nil { return errors.New("任务链已结束,无需强制结束") } oldStatus := cur.Status oldDock := cur.TargetDock oldTaskNo := cur.TaskNo // 1) 仅本地:当前段置终态(9=完成,与正常结束同口径,让链从 agvChainCurrent 消失) if err := s.ctx.EntClient.AgvTask.UpdateOneID(cur.ID).SetStatus("9").Exec(ctx); err != nil { return err } // 2) 仅本地:释放该任务占用的点位系统锁(避免后续派车被幽灵锁挡住) s.unlockAgvPointByTask(ctx, oldDock, oldTaskNo) // 3) 留痕:明确标注「仅清系统状态、未通知 RCS、实物需人工已处置」 if reason == "" { reason = "未填写(受控入口应强制选择)" } s.ctx.EventLog.Write(ctx, "agv.chain_force_end", operator, "", "agv_task", chainNo, "强制结束(仅解系统死锁,未通知RCS):段 "+oldTaskNo+" 状态 "+oldStatus+"→9,点位 "+oldDock+" 系统锁已释放;现场处置="+reason, map[string]any{"taskNo": oldTaskNo, "oldStatus": oldStatus, "targetDock": oldDock, "reason": reason}) return nil } // AgvChainList 手动链列表(任务进行中面板):全部 kind=MANUAL 段按链号分组, // AgvCode 取链内最新回写值,Active=链内存在非终态段。按链起始时间倒序。 func (s *Service) AgvChainList(ctx context.Context) ([]AgvChainInfo, error) { segs, err := s.ctx.EntClient.AgvTask.Query(). Where(agvtask.KindEQ("MANUAL")). Order(ent.Asc(agvtask.FieldID)). All(ctx) if err != nil { return nil, err } order := []string{} // 链号首次出现顺序(id 升序=创建顺序) byChain := map[string][]*ent.AgvTask{} for _, seg := range segs { cn := seg.ChainNo if cn == "" { cn = seg.TaskNo // 兜底:无链号的旧手动段自成一条 } if _, ok := byChain[cn]; !ok { order = append(order, cn) } byChain[cn] = append(byChain[cn], seg) } out := make([]AgvChainInfo, 0, len(order)) for i := len(order) - 1; i >= 0; i-- { // 最近的链在前 cn := order[i] list := byChain[cn] info := AgvChainInfo{ChainNo: cn, Segments: make([]AgvTaskView, 0, len(list))} for _, seg := range list { info.Segments = append(info.Segments, toAgvTaskView(seg)) if seg.AgvCode != "" { info.AgvCode = seg.AgvCode } if seg.Status != "9" && seg.Status != "5" { info.Active = true } } out = append(out, info) } return out, nil } // FreeDispatch 人工派车「开始用车」(用户 2026-11-14 定案):生成 MANUAL 起始段自动下发, // 不指定车号,由 RCS 自由分配;到位后回写 agv_code 即本链锁定车,后续节点全部沿用同一台车, // 直到「结束用车」释放。段类型必须是 MANUAL——链列表/链接口只认 MANUAL(此前生成 FREE 会导致 // 锁车延续与结束用车整个失效),FREE 仅保留给 MES AGV 页的旧自由调度单段。 // 前端弹「请确保路径畅通无杂物」后调用。 func (s *Service) FreeDispatch(ctx context.Context, source, target, operator, confirmForcePick string) (string, error) { if target == "" { return "", errors.New("请选择目标点位") } // 目标为接驳台时保持防撞强校验(有托盘/停用拒派) if err := s.guardTransportTarget(ctx, target); err != nil { return "", err } return s.dispatchAgvSegment(ctx, agvSegInput{ Kind: "MANUAL", BizType: "MANUAL", Source: source, Target: target, Operator: operator, ConfirmForcePick: confirmForcePick, }) } // DispatchPalletRecovery 托盘回收(WMS 托盘工作台触发,业务自动触发免弹窗): // 空车前往指定工位接驳台(GO_LOAD,装货点=有托盘的接驳台)→ 到位自动装车(工位专用台,零确认)→ // 运输段送回库房 JBT21 → 到位待令 → 确认卸货(空托盘上台)→ 空车自动回充。 // 2026-11-14 用户定案:工位侧不再有人工确认门槛,自动推进见 RefreshAgvTasks / autoLoadAtLineDock。 // 2026-11-04 定稿(Q5):JBT21 无空位(有托盘/在途任务占用)不派车——拉回来的托盘没地方放, // 前端按钮已禁用,此处后端兜底拒绝。 func (s *Service) DispatchPalletRecovery(ctx context.Context, dockCode, operator string) error { d, err := s.ctx.EntClient.Dock.Query().Where(dock.DockCodeEQ(dockCode)).First(ctx) if err != nil || d == nil { return fmt.Errorf("接驳台 %s 不存在", dockCode) } if d.Status == "DISABLED" { return fmt.Errorf("接驳台 %s 已停用", dockCode) } if !d.HasPallet { return fmt.Errorf("接驳台 %s 台账无托盘,无需回收(请先现场核实)", dockCode) } // JBT21 空位校验(2026-11-04 定稿 Q5):无空位提示并拒绝 if free, reason := s.Jbt21Free(ctx); !free { return fmt.Errorf("库房接驳台 %s 暂无空位:%s。请先卸走库房接驳台上的托盘后再派车", dockStoreCode, reason) } _, err = s.dispatchAgvSegment(ctx, agvSegInput{ Kind: "GO_LOAD", BizType: "PALLET", BizNo: dockCode, Source: "", Target: dockCode, Operator: operator, }) return err } // FindArrivedTaskNo 按 业务单据号+段类型 查「到位待令」任务号(WMS 装车确认只知道叫料单号)。 func (s *Service) FindArrivedTaskNo(ctx context.Context, bizNo, kind string) (string, error) { t, err := s.ctx.EntClient.AgvTask.Query(). Where(agvtask.BizNo(bizNo), agvtask.Kind(kind), agvtask.StatusEQ("ARRIVED")). Order(ent.Desc(agvtask.FieldCreatedAt)).First(ctx) if err != nil || t == nil { return "", fmt.Errorf("该叫料单暂无「到位待令」的 %s 段任务", kind) } return t.TaskNo, nil } // loadArrivedTask 校验任务存在、处于 ARRIVED 且段类型匹配。 func (s *Service) loadArrivedTask(ctx context.Context, taskNo string, kinds ...string) (*ent.AgvTask, error) { t, err := s.ctx.EntClient.AgvTask.Query().Where(agvtask.TaskNo(taskNo)).First(ctx) if err != nil || t == nil { return nil, errors.New("AGV 任务不存在") } if t.Status != "ARRIVED" { return nil, errors.New("任务不在「到位待令」状态,无法执行该确认动作") } okKind := false for _, k := range kinds { if t.Kind == k { okKind = true } } if !okKind { return nil, fmt.Errorf("该动作不适用于段类型 %s", t.Kind) } return t, nil } // guardTransportTarget 运输/自由调度目标防撞:接驳台必须启用且无托盘。 func (s *Service) guardTransportTarget(ctx context.Context, target string) error { pt, err := s.ctx.EntClient.AgvPoint.Query().Where(agvpoint.PositionCode(target)).Only(ctx) if err != nil || pt == nil { return fmt.Errorf("目标点位不存在:%s", target) } if !pt.Enabled { return fmt.Errorf("目标点位 %s 已停用,禁止派车", target) } if pt.IsDock && pt.DockID != nil { d, derr := s.ctx.EntClient.Dock.Get(ctx, *pt.DockID) if derr != nil || d == nil { return fmt.Errorf("目标接驳台不存在:%s", target) } if d.Status == "DISABLED" { return fmt.Errorf("目标接驳台 %s 已停用,禁止派车", target) } if d.HasPallet { return fmt.Errorf("目标接驳台 %s 已有托盘,禁止派车(防撞)", target) } // 2026-11-06 JBT21 危险场景加固:派车前实时读 PLC 传感器在位信号,有托盘硬拒 //(不再仅落预警)。PLC 不可达不阻断(保留台账判定);PLC mock 无真实传感器跳过。 if s.ctx.PLC != nil && !s.ctx.PLC.IsMock() { if has, perr := s.ctx.PLC.Get().QueryDockPallet(ctx, target); perr == nil && has { return fmt.Errorf("目标接驳台 %s 传感器检测到托盘,存在碰撞风险,禁止派车(请先清空接驳台或人工核实传感器)", target) } } } return nil } // setDockPalletByCode 动作写库:接驳台托盘台账增减(事件驱动,无轮询)。 // 同时做传感器↔台账相互认证(软校验):不一致落预警,供现场核实。 func (s *Service) setDockPalletByCode(ctx context.Context, dockCode string, hasPallet bool, palletRef, chainRef string) { if dockCode == "" || dockCode == agvChargePoint { return } d, err := s.ctx.EntClient.Dock.Query().Where(dock.DockCodeEQ(dockCode)).First(ctx) if err != nil || d == nil { return // 非 dock 类点位(充电位/待命位等)不落台账 } ref := palletRef if !hasPallet { ref = "" } if uerr := s.ctx.EntClient.Dock.UpdateOneID(d.ID).SetHasPallet(hasPallet).SetPalletRef(ref).Exec(ctx); uerr != nil { fmt.Println("接驳台台账更新失败:", uerr) return } s.ctx.EventLog.Write(ctx, "dock.pallet", "", "", "dock", dockCode, fmt.Sprintf("接驳台台账更新:hasPallet=%v(动作写库)", hasPallet), nil) // 传感器↔台账相互认证(动作时校验,best-effort) s.checkSensorVsLedger(ctx, dockCode, hasPallet, chainRef) } // checkSensorVsLedger 传感器↔台账相互认证:读 PLC 接驳台托盘传感器与 DB 台账比对, // 不一致落预警(软校验不阻断流程,由现场人工核实——禁止定时轮询,仅在动作时校验)。 func (s *Service) checkSensorVsLedger(ctx context.Context, dockCode string, expectHasPallet bool, ref string) { if s.ctx.PLC == nil || s.ctx.PLC.IsMock() { return // mock PLC 无真实传感器,跳过 } has, err := s.ctx.PLC.Get().QueryDockPallet(ctx, dockCode) if err != nil { return // PLC 不可达不阻断 } if has != expectHasPallet { _ = s.CreateAlert(ctx, "dock_sensor_mismatch", "警告", ref, "接驳台 "+dockCode+" 传感器与台账不符:传感器="+boolCn(has)+",台账="+boolCn(expectHasPallet)+",请现场核实") } } // decodeSegMaterials 还原段任务物料清单(空安全)。 func decodeSegMaterials(raw string) []AgvSubmitRow { if raw == "" { return nil } var rows []AgvSubmitRow _ = json.Unmarshal([]byte(raw), &rows) return rows } // chainRefOf 链引用(托盘 palletRef 用)。 func chainRefOf(t *ent.AgvTask) string { if t.ChainNo != "" { return t.ChainNo } return t.TaskNo } // boolCn bool 转中文。 func boolCn(b bool) string { if b { return "有" } return "无" }