Files
bj_power/bj_power_mes/internal/logic/agv.go
T
SunYF 4c4cda1d41 feat: 移除工艺物料与混产模板实体、新增产线清线与 PLC 监控实时推送、看板双屏增强
- 移除实体:MES 删除 FlowMaterial(工艺物料)与 MixProductionTemplate(混产模板)全套(schema/ent 生成码/handler/logic),清理关联路由与种子
- 新增功能:产线清线(line_clearance handler + logic)、PLC 监控 WebSocket 实时推送(ws/plc_monitor_hub + handler)
- 看板增强:新增管理屏与 KPI 组件(BoardManage/BoardKpi),调整演示屏 Mock 与各看板面板
- MES 完善:PLC 匹配/扭矩扫描/签收、工艺卡 PDF 与工单、AGV 链路、叫料/备料/在制品/短料预测等逻辑与前端调整
- 工位终端:删除离线面板 OfflinePanel,调整主界面/物料面板与 api/store/handler/路由
- WMS:AGV 托盘、物料与 MES 客户端调整及前端帮助/基础数据/叫料/托盘页
- 文档:更新产线API/客户问题/案例/部署手册/问题记录
2026-11-19 08:31:05 +08:00

1816 lines
83 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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"
"github.com/zeromicro/go-zero/core/logx"
)
// ============ 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"` // 任务号或人工原因
LockedTaskInfo string `json:"lockedTaskInfo"` // 任务锁定详情(2026-11-17 用户要求:状态/模板/目标/时间,人要有判定依据);manual 锁为空
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))
// 2026-11-17 用户要求:任务锁定的点位必须能看到「是什么任务锁定了它」——批量查任务摘要做判定依据
lockedTaskNos := make([]string, 0, len(pts))
for _, p := range pts {
if p.Locked && p.LockedBy == "system" && p.LockedReason != "" {
lockedTaskNos = append(lockedTaskNos, p.LockedReason)
}
}
taskInfoByNo := map[string]string{}
if len(lockedTaskNos) > 0 {
tasks, _ := s.ctx.EntClient.AgvTask.Query().Where(agvtask.TaskNoIn(lockedTaskNos...)).All(ctx)
for _, t := range tasks {
dispatchAt := "—"
if t.DispatchedAt > 0 {
dispatchAt = time.Unix(t.DispatchedAt, 0).Format("01-02 15:04")
}
taskInfoByNo[t.TaskNo] = "任务 " + t.TaskNo + ":" + agvTaskStatusText(t.Status) +
" · 模板 " + t.TemplateType + " · " + t.SourceDock + " → " + t.TargetDock +
" · 下发于 " + dispatchAt
}
}
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,
LockedTaskInfo: taskInfoByNo[p.LockedReason],
}
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,
}
}
// agvMapShortName 读 yaml Agv.MapShortName(2026-11-17 用户定案:写死 yaml,不在基础设置页显示)。
func (s *Service) agvMapShortName(_ context.Context) string {
return strings.TrimSpace(s.ctx.Config.Agv.MapShortName)
}
// ListAgvVehicles 只读获取车辆状态(3.1.7 queryAgvStatus),供前端展示闲忙/充电/电量/位置。
// 纯只读:调度完全交给 RCS 自身,本系统不干预。Mock 模式返回示例车。
// 地图简称必须由人工在「基础设置」填写(2026-11-17 用户裁决:禁止自动探测/穷举,不掩盖配置缺失)。
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, s.agvMapShortName(ctx))
}
mapShortName := s.agvMapShortName(ctx)
if mapShortName == "" {
return nil, errors.New("AGV 地图简称未配置。请在部署机 etc/bj_power_mes-api.yaml 的 Agv.MapShortName 填写海康 RCS 真实地图简称后重启服务")
}
return s.ctx.Agv.QueryAgvStatus(ctx, mapShortName)
}
// 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
// pendingExec:RCS 仍报「执行中」且已分车的任务 —— 用于到位探测(见循环后注释)
type execTask struct {
id int
taskNo, agvCode, target string
autoEnd bool
}
var pendingExec []execTask
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
}
// 2026-11-17 用户裁决推翻「工位零确认」:让车来工位与让车离开是两步操作,
// 车到工位后必须人点「确认装车回库」才离开。工位 GO_LOAD 到位进 ARRIVED,
// 由页面操作列的确认按钮调 line_load_confirm 完成装车+回库(见 ConfirmLineDockLoad)。
// 系统绝不自动装车、绝不自动派车离开,失败也不自动重试(人可重试确认)。
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「到位待令」。
// 托盘回收(remark 带 AUTO_LOAD)到位自动装车免确认;退料/叫料仍由人工确认。
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)
}
if err := upd.Exec(ctx); err == nil {
s.maybeAutoLineDockLoad(ctx, t)
changed++
}
continue
case "5": // 取消完成
upd.SetStatus("5")
default: // 1 已创建 / 2 执行中
upd.SetStatus(st)
// 2026-11-17 到位探测候选:RCS 对「空车接货到位等待」类任务(C01)永远保持 2、不发 end 回调,
// 也不置 9——车停下等装货在 RCS 语义里仍属「执行中」(16:44 实测:车 33517 到点后
// queryTaskStatus 恒 2、queryAgvStatus 里该车 status=4 任务空闲)。已分车的记录下来探测。
if st == "2" && agvCode != "" {
pendingExec = append(pendingExec, execTask{id: t.ID, taskNo: t.TaskNo, agvCode: agvCode, target: t.TargetDock, autoEnd: t.AutoEnd})
}
}
if err := upd.Exec(ctx); err == nil {
changed++
}
}
// 2026-11-17 到位判定增强(用户实测反馈:车已到但界面永远「执行中」):对已分车且 RCS 仍报执行中的任务,
// 查车辆实时状态;该车 status=4「任务空闲」即视为已到达等待点(RCS 把到位等待的车置回空闲,
// speed=0;行驶中/避让时不会空闲)。判定与 st=9 同路径,事件注明来源便于追溯。
if len(pendingExec) > 0 && !s.ctx.Agv.Disable() {
if vs, verr := s.ctx.Agv.QueryAgvStatus(ctx, s.agvMapShortName(ctx)); verr == nil {
free := map[string]bool{}
for _, v := range vs {
if v.Status == "4" {
free[v.RobotCode] = true
}
}
for _, e := range pendingExec {
if !free[e.agvCode] {
continue
}
upd := s.ctx.EntClient.AgvTask.UpdateOneID(e.id)
if e.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", e.taskNo,
"AGV已到位(车 "+e.agvCode+" 空闲于 "+e.target+",车辆状态探测判定),等待确认", nil)
}
if err := upd.Exec(ctx); err == nil {
// 托盘回收(remark 带 AUTO_LOAD)到位自动装车免确认
if t, gerr := s.ctx.EntClient.AgvTask.Get(ctx, e.id); gerr == nil {
s.maybeAutoLineDockLoad(ctx, t)
}
changed++
}
}
}
}
// 2026-11-17 死锁兜底:清掉「任务已终态但 system 锁残留」的点位(历史回调 cancel/force-end
// 漏解锁会留下僵尸锁,把点位永久占死,后续派车全被 preDispatchPointCheck 拒绝)。幂等,
// 每轮刷新执行一次;JBT21 例外不动(库房接驳台由库管手动解锁,见 agv_point_lock.go 注释)。
s.cleanupStaleAgvPointLocks(ctx)
return changed, nil
}
// cleanupStaleAgvPointLocks 兜底清理终态任务的残留系统锁。
// 只清 locked_by=system 且锁定任务已 5(取消)/9(已完成)/FAILED,或锁定任务记录已不存在(历史脏数据);
// manual 锁、JBT21、正在执行(1/2/ARRIVED)的任务锁一律不动,避免误放占用。
func (s *Service) cleanupStaleAgvPointLocks(ctx context.Context) {
pts, err := s.ctx.EntClient.AgvPoint.Query().
Where(agvpoint.Locked(true), agvpoint.LockedBy("system")).All(ctx)
if err != nil || len(pts) == 0 {
return
}
taskNos := make([]string, 0, len(pts))
for _, p := range pts {
if p.LockedReason != "" {
taskNos = append(taskNos, p.LockedReason)
}
}
found := map[string]bool{}
terminal := map[string]bool{}
if len(taskNos) > 0 {
tasks, terr := s.ctx.EntClient.AgvTask.Query().Where(agvtask.TaskNoIn(taskNos...)).All(ctx)
if terr != nil {
logx.WithContext(ctx).Errorf("[AGV][lock] 终态锁清理:查询锁定任务失败,本轮跳过: %v", terr)
return // 查不到就不能判定,宁可不动,避免误清在途锁
}
for _, t := range tasks {
found[t.TaskNo] = true
if t.Status == "5" || t.Status == "9" || t.Status == "FAILED" {
terminal[t.TaskNo] = true
}
}
}
for _, p := range pts {
if p.PositionCode == dockStoreCode || p.LockedReason == "" {
continue // JBT21 手动解锁例外 / 无任务号的 system 锁不动
}
if !terminal[p.LockedReason] && found[p.LockedReason] {
continue // 任务在执行中,锁有效
}
if uerr := s.ctx.EntClient.AgvPoint.UpdateOneID(p.ID).
SetLocked(false).SetLockedBy("").SetLockedReason("").SetLockedAt(0).Exec(ctx); uerr != nil {
logx.WithContext(ctx).Errorf("[AGV][lock] 清理残留锁失败 点位=%s 任务=%s: %v", p.PositionCode, p.LockedReason, uerr)
continue
}
reason := "锁定任务已终态"
if !found[p.LockedReason] {
reason = "锁定任务记录不存在(历史脏数据)"
}
logx.WithContext(ctx).Infof("[AGV][lock] 自动清理残留系统锁 点位=%s 任务=%s(%s)", p.PositionCode, p.LockedReason, reason)
s.ctx.EventLog.Write(ctx, "agv.point_unlock", "system", "", "agv_point", p.PositionCode,
"兜底清理残留系统锁:"+p.LockedReason+"("+reason+"),点位已释放", 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"
}
// ConfirmLineDockLoad 工位接驳台「确认装车回库」(2026-11-17 用户裁决):
// 车到工位后停在 ARRIVED,人点确认才装车 + 下发回库运输段。车不会自己离开,失败也不自动重试。
// 与 ConfirmLoadAndGo 同构,但目标固定为库房接驳台 JBT21(工位台专用,无需人选目标)。
func (s *Service) ConfirmLineDockLoad(ctx context.Context, taskNo, operator string) error {
t, err := s.loadArrivedTask(ctx, taskNo, "GO_LOAD")
if err != nil {
return err
}
if !s.isLineDock(ctx, t.TargetDock) {
return errors.New("该任务不是工位接驳台取货任务,请用对应的确认动作")
}
if free, reason := s.Jbt21Free(ctx); !free {
return fmt.Errorf("库房接驳台 %s 暂无空位:%s", dockStoreCode, reason)
}
// 装货点托盘被背走 → 台面清空;该车置「有托盘」
s.setDockPalletByCode(ctx, t.TargetDock, false, "", chainRefOf(t))
s.setAgvLoadedState(ctx, t.AgvCode, true, "AUTO_LOAD", operator)
// 2026-11-18 定稿:先发回库运输段(锁同一台车),成功后本段置9 + cancel 旧任务
if _, derr := s.dispatchAgvSegment(ctx, agvSegInput{
Kind: "TRANSPORT", BizType: t.BizType, BizNo: t.BizNo, ChainNo: t.ChainNo,
Source: t.TargetDock, Target: dockStoreCode,
Materials: decodeSegMaterials(t.MaterialsJSON), Operator: operator,
AgvCode: t.AgvCode,
}); derr != nil {
return fmt.Errorf("回库运输段下发失败: %w", derr)
}
s.ctx.EntClient.AgvTask.UpdateOneID(t.ID).SetStatus("9").SetArrivedAt(time.Now().Unix())
s.cancelOldRcsTask(ctx, t.TaskNo, operator, "工位装车回库衔接")
// 车驶离工位 → 释放该点系统锁
s.unlockAgvPointByTask(ctx, t.TargetDock, t.TaskNo)
s.ctx.EventLog.Write(ctx, "agv.line_dock_load_confirm", operator, "", "agv_task", t.TaskNo,
"工位接驳台 "+t.TargetDock+" 装车,送回 "+dockStoreCode+"(锁车 "+t.AgvCode+"),旧任务已通知取消", nil)
return nil
}
// maybeAutoLineDockLoad 托盘回收(空托盘)到位免确认(2026-11-18 定稿 A 方案):
// GO_LOAD 段 remark 带 agvAutoLoadMark 时,到位(ARRIVED)即自动走 ConfirmLineDockLoad 装车回库;
// 退料(盘上有料)无此标记,仍停在 ARRIVED 等人点「确认装车回库」。用于 RefreshAgvTasks / ApplyAgvCallback 到位钩子。
// 失败只留痕不重试(保持 ARRIVED,人可重试确认)。
func (s *Service) maybeAutoLineDockLoad(ctx context.Context, t *ent.AgvTask) {
if t == nil || t.Kind != "GO_LOAD" || !strings.Contains(t.Remark, agvAutoLoadMark) {
return
}
if err := s.ConfirmLineDockLoad(ctx, t.TaskNo, "system"); err != nil {
s.ctx.EventLog.Write(ctx, "agv.pallet_auto_load_fail", "system", "", "agv_task", t.TaskNo,
"托盘回收到位自动装车失败(保留到位待令,可人工确认):"+err.Error(), 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
}
// CancelRcsTaskByCode 按海康 taskCode 取消任意任务(2026-11-17 用户诉求:
// "AGV 后台很多历史任务都是进行中、MES 取消不了")。与 CancelAgvTask 的区别:
// 不要求任务在 MES 本地表——非本系统下发、遗留死锁在海康后台的任务,只要知道 taskCode
// 就能直接调海康 cancelTask 清掉(海康 cancelTask 支持按 taskCode,见文档 §cancelTask)。
// 本地有该任务时一并清状态+解锁点位;没有则只通知海康并留痕,让现场从死胡同里出来。
func (s *Service) CancelRcsTaskByCode(ctx context.Context, taskCode, reason, operator string) error {
taskCode = strings.TrimSpace(taskCode)
if taskCode == "" {
return errors.New("任务号必填")
}
if s.ctx.Agv.Disable() {
return errors.New("当前为模拟模式,无真实海康任务可取消")
}
// CancelTask 内部固定 forceCancel=0(取消后货架放地上,人工处置现场),不擅自让车背货继续跑。
if cerr := s.ctx.Agv.CancelTask(ctx, taskCode, reason); cerr != nil {
logx.WithContext(ctx).Errorf("[AGV][cancel] 海康取消失败 taskCode=%s: %v", taskCode, cerr)
return fmt.Errorf("海康取消任务 %s 失败:%w", taskCode, cerr)
}
// 本地有这条任务 → 同步终态+释放点位系统锁(与 CancelAgvTask 同口径)
if t, terr := s.ctx.EntClient.AgvTask.Query().Where(agvtask.TaskNo(taskCode)).First(ctx); terr == nil && t != nil {
s.unlockAgvPointByTask(ctx, t.TargetDock, t.TaskNo)
_ = s.ctx.EntClient.AgvTask.UpdateOneID(t.ID).SetStatus("5").SetRemark(reason).Exec(ctx)
}
s.ctx.EventLog.Write(ctx, "agv.rcs_cancel_by_code", "", operator, "agv_task", taskCode,
"按海康任务号取消(含非 MES 下发任务):"+taskCode+",原因:"+reason, map[string]any{"taskCode": taskCode, "reason": reason})
logx.WithContext(ctx).Infof("[AGV][cancel] 海康任务 %s 已取消(操作人 %s)", taskCode, operator)
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}
}
// ApplyAgvWarnCallback 海康 RCS-Lite 严重告警推送(文档 §3.1.8 warnCallback,10 秒一次)。
// 告警会导致 AGV 停止运行(含急停/安全告警/故障),现场必须可见——落预警中心(按
// 告警码+车号 30 分钟去重,防 10s 推送刷爆)+ event_log 留痕。回调不携带我方鉴权,
// 与 agvCallback 同走防火墙/IP 白名单隔离。
func (s *Service) ApplyAgvWarnCallback(ctx context.Context, agvCode, mainCode, mainName, subCode, subName, beginTime string) error {
if agvCode == "" && mainCode == "" && subCode == "" {
return errors.New("告警报文为空")
}
name := subName
if name == "" {
name = mainName
}
if name == "" {
name = "未命名告警"
}
msg := "海康 AGV 告警:车 " + agvCode + "," + name
if mainCode != "" || subCode != "" {
msg += "(主码 " + mainCode + "/子码 " + subCode + ")"
}
if beginTime != "" {
msg += ",开始时间 " + beginTime
}
target := agvCode
if target == "" {
target = "AGV-" + mainCode
}
logx.WithContext(ctx).Errorf("[AGV][warn] 海康告警回调 车=%s 主=%s/%s 子=%s/%s", agvCode, mainCode, mainName, subCode, subName)
created, err := s.CreateAlertDedup(ctx, "agv_rcs_warn", "严重", target, msg, 30)
if err != nil {
return err
}
if created {
s.ctx.EventLog.Write(ctx, "agv.rcs_warn", "system", "", "agv", target,
msg, map[string]any{"agvCode": agvCode, "mainCode": mainCode, "subCode": subCode, "beginTime": beginTime})
}
return nil
}
// 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 {
// 2026-11-17:不再静默丢弃——海康回调一个 MES 不认识的 taskCode,意味着有
// "非本系统下发的任务"在现场跑(用户明确要求这类要能看见、能处置)。记日志+
// 落预警(30 分钟去重防刷屏),运维据此可去海康后台按 taskCode 取消。
logx.WithContext(ctx).Errorf("[AGV][callback] 未知任务回调 taskCode=%s method=%s robot=%s(非 MES 下发,落预警提示)", taskCode, method, robotCode)
_, aerr := s.CreateAlertDedup(ctx, "agv_unknown_callback", "警告", taskCode,
"海康上报了非本系统下发的任务 "+taskCode+"("+method+")"+":该车现场正在执行 MES 之外的任务,请到海康后台核对;MES 无法跟踪其状态", 30)
if aerr != nil {
logx.WithContext(ctx).Errorf("[AGV][callback] 未知任务回调落预警失败: %v", aerr)
}
return nil
}
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
}
// 2026-11-17 现场事故修复:海康后台取消任务 → method=cancel 回调把本地置 5,但没释放
// 目标点位的系统锁——点位被已取消任务永久占用,后续派车全被防撞守卫拒绝(死胡同根源)。
// 取消=任务终止,与 CancelAgvTask 同口径必须解锁。
if status == "5" {
s.unlockAgvPointByTask(ctx, t.TargetDock, t.TaskNo)
s.ctx.EventLog.Write(ctx, "agv.point_unlock", "", "", "agv_task", t.TaskNo,
"海康回调取消(method=cancel),任务终态自动解锁点位 "+t.TargetDock, nil)
}
if arrived && status == "ARRIVED" {
s.ctx.EventLog.Write(ctx, "agv.arrive", "", "", "agv_task", t.TaskNo,
"AGV已到位(回调),等待人工确认 "+t.TargetDock, map[string]any{"method": method})
// 托盘回收(remark 带 AUTO_LOAD)到位自动装车免确认;退料/叫料仍等人点
s.maybeAutoLineDockLoad(ctx, t)
}
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
// EmptyRun 空车接货首段:用 C01 空车模板,只传到达点、不指定 agv、不举升。
// 2026-11-18 定稿:所有空车去程首段(Source 为空)统一走 C01,不再只限人工派车。
EmptyRun bool
// AutoLoad 到位即装车免人工确认(2026-11-18 定稿):托盘回收(空托盘)置 true;
// 退料(盘上有料)必须 false→保留 line_load_confirm 人工确认。落库为 remark 标记供到位钩子识别。
AutoLoad bool
}
// agvAutoLoadMark GO_LOAD 段 remark 标记:到位后自动装车放行(托盘回收),无需人工点确认。
const agvAutoLoadMark = "[AUTO_LOAD]"
// 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
}
}
// guardAgvConcurrency 派车并发闸门(2026-11-18 用户定稿):
// 只对「新建链首段」拦截(衔接段同链、旧任务取消都不增加并发)。取 RCS 车辆总数 N(排除 exclType=1),
// 与本地在途链数(status 1/2/ARRIVED,按 chain_no 去重)比较,>= N 时拒绝,防止"2 台车发出 3 个任务"。
// RCS 车辆状态查询失败时不阻断派车(网络/白名单问题由 SubmitTask 自身失败暴露),仅留痕。
func (s *Service) guardAgvConcurrency(ctx context.Context) error {
vs, verr := s.ctx.Agv.QueryAgvStatus(ctx, s.agvMapShortName(ctx))
if verr != nil {
logx.WithContext(ctx).Infof("[AGV][concurrency] 车辆状态查询失败,本次放行:%v", verr)
return nil
}
n := 0
for _, v := range vs {
if v.ExclType != "1" {
n++
}
}
if n <= 0 {
return nil
}
rows, err := s.ctx.EntClient.AgvTask.Query().
Where(agvtask.StatusIn("1", "2", "ARRIVED")).All(ctx)
if err != nil {
return nil
}
chains := map[string]bool{}
for _, r := range rows {
chains[r.ChainNo] = true
}
if len(chains) >= n {
return fmt.Errorf("当前无空闲 AGV,请等待任务完成(在途任务 %d / AGV 总数 %d)", len(chains), n)
}
return nil
}
// dispatchAgvSegment 创建一段任务并自动下发 RCS(业务触发统一走此口)。返回本段 taskNo。
func (s *Service) dispatchAgvSegment(ctx context.Context, in agvSegInput) (string, error) {
if in.Target == "" {
return "", fmt.Errorf("缺少目标点位")
}
// 并发闸门:仅新建链首段(ChainNo 空)拦截;衔接段同链不占新名额
if in.ChainNo == "" {
if err := s.guardAgvConcurrency(ctx); err != nil {
return "", err
}
}
// 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。
// 2026-11-17 用户拍板:人工派车首段(空车去接货点)用 C01 空车模板——不举升、不指定 agv;
// 下一站仍按目标点硬件属性走 B01(接驳台)/B02(无接驳台),业务逻辑不变,仅首段模板不同。
tmpl, terr := s.agvTemplateType(ctx, in.Source, in.Target)
if terr != nil {
return "", terr
}
if in.EmptyRun || in.Source == "" {
// 2026-11-18 定稿:所有空车去程首段(Source 空=单点 path)统一 C01——只到达点、不举升、不指定车。
// 载货衔接段 Source 非空,仍按目标点走 B01(接驳台)/B02(虚拟点)。
tmpl = "EMPTY"
}
taskNo := "AGV" + strings.ToUpper(uuid.NewString()[:10])
chain := in.ChainNo
if chain == "" {
chain = taskNo
}
mats, _ := json.Marshal(in.Materials)
remark := ""
if in.AutoLoad {
remark = agvAutoLoadMark
}
if pt := s.agvPointByCode(ctx, in.Target); pt != nil && pt.ForcePick {
if remark != "" {
remark += " "
}
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
switch tmpl {
case "EMPTY":
// 2026-11-17 C01:首段空车接货模板,只传到达点(in.Source 为空时 SubmitTask 自动单点 path)、不指定车。
submitTmpl = s.CfgStr(ctx, CfgAgvTaskTypEmpty, "C01")
case "LIFT":
submitTmpl = s.CfgStr(ctx, CfgAgvTaskTypLift, "B01")
default:
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" 表示库管已对强提风险目标点位完成人工二次确认。
// 业务口径:库房装货点 JBT21 多台共用,由库管确认装车防拿错;
// 工位专用接驳台取货走人工「确认装车回库」ConfirmLineDockLoad,不进本流程。
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)
}
// 2026-11-18 定稿:先发新段(锁同一台车),成功后再 cancel 旧任务(清 RCS 僵尸任务)
_, 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,
AgvCode: t.AgvCode, ConfirmForcePick: confirmForcePick,
})
if derr != nil {
return fmt.Errorf("运输段下发失败: %w", derr)
}
s.ctx.EntClient.AgvTask.UpdateOneID(t.ID).SetStatus("9").Exec(ctx)
s.cancelOldRcsTask(ctx, t.TaskNo, operator, "叫料装车衔接")
s.ctx.EventLog.Write(ctx, "agv.load_confirm", operator, "", "agv_task", taskNo,
"确认装车并送货,运输段 "+t.TargetDock+"→"+nextDock+"(锁车 "+t.AgvCode+"),旧任务已通知取消", nil)
return nil
}
// cancelOldRcsTask 衔接/收尾后清理海康侧旧任务(best-effort,失败只留痕不阻断主流程)。
func (s *Service) cancelOldRcsTask(ctx context.Context, taskNo, operator, scene string) {
if taskNo == "" {
return
}
if err := s.ctx.Agv.CancelTask(ctx, taskNo, scene); err != nil {
s.ctx.EventLog.Write(ctx, "agv.rcs_cancel", "system", "", "agv_task", taskNo,
scene+":通知海康取消旧任务 "+taskNo+" 未成功(RCS 可能已自行结束):"+err.Error(), nil)
return
}
s.ctx.EventLog.Write(ctx, "agv.rcs_cancel", "system", "", "agv_task", taskNo,
scene+":已通知海康取消旧任务 "+taskNo, 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)
}
}
}
// 2026-11-18 定稿:业务终点直接 cancelTask 结束海康任务,不再下发 EMPTY_RETURN 指挥回充;
// 车辆卸货后由 RCS 自行处置(回充/待命),MES 不再遥控。
s.cancelOldRcsTask(ctx, t.TaskNo, operator, "卸货完成收尾")
s.ctx.EventLog.Write(ctx, "agv.unload_confirm", operator, "", "agv_task", taskNo,
"卸货完成并放行,托盘落位 "+t.TargetDock+",海康任务已通知取消(车辆由 RCS 自行处置)", 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)
}
// 2026-11-18 定稿:终点 cancelTask,不再下发 EMPTY_RETURN
s.cancelOldRcsTask(ctx, t.TaskNo, operator, "自由调度结束收尾")
s.ctx.EventLog.Write(ctx, "agv.free_finish", operator, "", "agv_task", taskNo,
"自由调度结束,海康任务已通知取消(车辆由 RCS 自行处置)", 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"` // 已走节点(按段创建顺序)
Realtime *AgvChainRealtime `json:"realtime"` // RCS 实时快照(2026-11-17:本地判定与 API 事实对比;仅进行中且已分车的链返回)
}
// 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
}
// agvTaskStatusText 任务状态中文文本(点位锁定详情等展示用,与前端口径一致)。
func agvTaskStatusText(st string) string {
switch st {
case "1":
return "已派车待分车"
case "2":
return "执行中"
case "ARRIVED":
return "已到位待确认"
case "5":
return "已取消"
case "9":
return "已完成"
case "FAILED":
return "下发失败"
default:
return st
}
}
// 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) {
logx.WithContext(ctx).Infof("[AGV][chain-next] 开始 chain=%s source=%s target=%s operator=%s forcePick=%s", chainNo, source, target, operator, confirmForcePick)
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 车辆信息尚未回写,请点「刷新状态」获取当前车辆后再下发下一节点")
}
// 2026-11-18 定稿:不再调 continueTask;新段锁车下发成功后 cancel 旧任务(清 RCS 僵尸任务)
// 目标防撞强校验(与手动派车同口径:接驳台有托盘/停用拒派)
if err := s.guardTransportTarget(ctx, target); err != nil {
logx.WithContext(ctx).Errorf("[AGV][chain-next] chain=%s 目标=%s 防撞校验拒绝: %v", chainNo, target, err)
return "", err
}
src := strings.TrimSpace(source)
if src == "" {
src = cur.TargetDock // 默认从上一节点落点出发
}
// 先发下一段(锁同一台车),成功后本段置 9 + cancel 旧任务;失败回滚本段状态
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 {
logx.WithContext(ctx).Errorf("[AGV][chain-next] chain=%s 下一节点下发失败 src=%s target=%s: %v", chainNo, src, target, derr)
return "", fmt.Errorf("下一节点下发失败: %w", derr)
}
s.ctx.EntClient.AgvTask.UpdateOneID(cur.ID).SetStatus("9").Exec(ctx)
s.cancelOldRcsTask(ctx, cur.TaskNo, operator, "人工派车下一站衔接")
logx.WithContext(ctx).Infof("[AGV][chain-next] chain=%s 下一节点下发成功 taskNo=%s %s->%s(锁车 %s),旧任务已通知取消", chainNo, taskNo, src, target, agvCode)
// 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 尚未到位,到位后才能结束任务")
}
// 2026-11-18 定稿:不再调 continueTask
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, s.agvMapShortName(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)
}
// 2026-11-18 定稿:业务终点直接 cancelTask,不再下发 EMPTY_RETURN 指挥回充
s.cancelOldRcsTask(ctx, cur.TaskNo, operator, "人工派车结束用车收尾")
endNote := ""
if force {
endNote = ",人工确认无托盘强制结束(RCS 查询失败)"
}
s.ctx.EventLog.Write(ctx, "agv.chain_end", operator, "", "agv_task", chainNo,
"手动链任务结束(锁车 "+agvCode+")"+endNote+",海康任务已通知取消(车辆由 RCS 自行处置)", 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
// 0) RCS 侧防僵尸(2026-11-17 现场教训):任务受理中(1/2)且未派到车(agvCode 空)时,
// 海康侧没有车、没有货,cancelTask 零物理风险——必须顺手通知海康取消,
// 否则 RCS 侧会堆积 status=2 的僵尸任务(今天三条 C01 全是这么留下的)。
// 有车段维持 2026-11-16 定案不调海康:车可能背着货架,cancelTask 会卸货扔路上。
rcsCancelNote := "无(本段无进行中任务)"
if (oldStatus == "1" || oldStatus == "2") && cur.AgvCode == "" {
if cerr := s.ctx.Agv.CancelTask(ctx, oldTaskNo, reason); cerr != nil {
rcsCancelNote = "已尝试但失败(RCS 侧可能残留任务 " + oldTaskNo + ",需海康后台确认):" + cerr.Error()
} else {
rcsCancelNote = "已通知海康取消任务 " + oldTaskNo + "(无车无货,安全)"
}
}
// 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,
"强制结束(仅解系统死锁):段 "+oldTaskNo+" 状态 "+oldStatus+"→9,点位 "+oldDock+" 系统锁已释放;RCS侧="+rcsCancelNote+";现场处置="+reason,
map[string]any{"taskNo": oldTaskNo, "oldStatus": oldStatus, "targetDock": oldDock, "reason": reason, "rcsCancel": rcsCancelNote})
return nil
}
// AgvChainList 手动链列表(任务进行中面板):全部 kind=MANUAL 段按链号分组,
// AgvCode 取链内最新回写值,Active=链内存在非终态段。按链起始时间倒序。
// AgvChainRealtime 链当前段的 RCS 实时快照(2026-11-17 用户要求:本地判定必须能与 API 事实对比)。
// 来源=queryTaskStatus(任务状态/车号)+ queryAgvStatus(车辆实时状态/电量/坐标),均为 RCS 真实回包。
type AgvChainRealtime struct {
Source string `json:"source"` // ok=取到 RCS 实时 / unavailable=RCS 未取到(网络或超时)
TaskCode string `json:"taskCode"` // 查询的任务号
TaskStatus string `json:"taskStatus"` // RCS 实时任务状态:1 已创建/2 执行中/5 取消/9 已结束
AgvCode string `json:"agvCode"` // RCS 实际分的车(空=未分车)
RobotStatus string `json:"robotStatus"` // 车辆实时状态:4 空闲/2 执行中/7 充电/81 等(协议 5.1)
Battery string `json:"battery"` // 电量 %
PosX string `json:"posX"` // 地图坐标 mm(对照海康地图)
PosY string `json:"posY"`
Note string `json:"note"` // 与本地状态的一致性判定说明
}
// buildChainRealtime 取链当前段的 RCS 实时快照(整体 4 秒超时,失败返回 unavailable,绝不拖垮页面轮询)。
func (s *Service) buildChainRealtime(ctx context.Context, cur *ent.AgvTask) *AgvChainRealtime {
rt := &AgvChainRealtime{Source: "unavailable", TaskCode: cur.TaskNo}
if s.ctx.Agv == nil || s.ctx.Agv.Disable() {
return rt
}
rctx, cancel := context.WithTimeout(ctx, 4*time.Second)
defer cancel()
st, agvCode, qerr := s.ctx.Agv.QueryTask(rctx, cur.TaskNo)
if qerr != nil {
rt.Note = "RCS 任务查询失败:" + qerr.Error()
return rt
}
rt.TaskStatus, rt.AgvCode = st, agvCode
if agvCode == "" {
rt.Note = "RCS 尚未分车(无车号,无法查车辆实时状态)"
return rt
}
vs, verr := s.ctx.Agv.QueryAgvStatus(rctx, s.agvMapShortName(rctx))
if verr != nil {
rt.Note = "RCS 任务状态已取到(" + st + "),车辆状态查询失败:" + verr.Error()
return rt
}
statusText := map[string]string{"1": "已创建", "2": "执行中", "5": "已取消", "9": "已结束"}
if txt, ok := statusText[st]; ok {
rt.Note = "RCS 任务实时=" + txt
}
for _, v := range vs {
if v.RobotCode != agvCode {
continue
}
robotText := map[string]string{
"1": "任务完成", "2": "任务执行中", "3": "任务异常", "4": "空闲", "5": "暂停",
"6": "举升货架", "7": "充电中", "8": "弧线行走", "9": "充满维护",
}
rt.RobotStatus, rt.Battery = v.Status, fmt.Sprintf("%.0f", v.Battery)
rt.PosX, rt.PosY = fmt.Sprintf("%.0f", v.PosX), fmt.Sprintf("%.0f", v.PosY)
if txt, ok := robotText[v.Status]; ok {
rt.Note += ";车辆实时=" + txt + "(" + v.Status + ")"
} else {
rt.Note += ";车辆实时状态=" + v.Status + "(协议 5.1 外的扩展码)"
}
if v.Status == "7" {
rt.Note += "(车辆已离开作业点去充电——本地「已到位」已是历史判定,车不在点位上)"
}
break
}
return rt
}
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))}
var cur *ent.AgvTask
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
if cur == nil {
cur = seg // 最新非终态段(列表按 id 升序,第一个非终态即当前段)
}
}
}
// 2026-11-17 用户要求:进行中的链附带 RCS 实时快照,让「已到位/执行中」有 API 事实可对比
if info.Active && cur != nil && cur.AgvCode != "" && cur.Status != "FAILED" {
info.Realtime = s.buildChainRealtime(ctx, cur)
}
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,
EmptyRun: true, // 首段空车接货:C01 只到达点、不举升、不指定 agv(2026-11-17 用户拍板)
})
}
// DispatchPalletRecovery 托盘回收(WMS 托盘工作台触发,业务自动触发免弹窗):
// 空车前往指定工位接驳台(GO_LOAD,装货点=有托盘的接驳台)→ 到位待令 → 人点「确认装车回库」→
// 运输段送回库房 JBT21 → 到位待令 → 确认卸货(空托盘上台)→ 空车自动回充。
// 2026-11-17 用户裁决:车到工位后须人同意才离开,见 ConfirmLineDockLoad。
// 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)
}
// 传感器校验(2026-11-18 定稿):点「派 AGV 回收」时若传感器反馈该接驳台无托盘,提示清楚并拒绝;
// PLC 离线时回退台账判定,台账也无托盘同样拒绝。
hasPallet := d.HasPallet
plcOk := false
if s.ctx.PLC != nil && !s.ctx.PLC.IsMock() {
if has, e := s.ctx.PLC.Get().QueryDockPallet(ctx, dockCode); e == nil {
plcOk = true
hasPallet = has
}
}
if plcOk && !hasPallet {
return fmt.Errorf("接驳台 %s 传感器未检测到托盘,无需派车回收(请现场确认托盘已放到台面)", dockCode)
}
if !plcOk && !hasPallet {
return fmt.Errorf("接驳台 %s 台账无托盘(PLC 离线无法核实),无需回收", 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,
AutoLoad: true, // 托盘回收(空托盘):到位即装车免人工确认
})
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-17 补:必须限制等待时长——PLC TCP dial 默认 ~10s,会把 HTTP 请求拖到
// go-zero slowcall 熔断直接 503(18:07 实测)。2.5 秒超时即按定案放行并留痕。
// 2026-11-17 二次修复:纯 WithTimeout 打断不了锁等待——plc/tcp.go readBytes 先
// s.mu.Lock() 再 ensure()→Connect(),PLC 不可达时监控页轮询持锁拨号可达 30s,
// mutex 等待不感知 ctx,本请求照样挂到 slowcall 10s 熔断 503(18:21 实测)。
// 改为 goroutine + select 硬切 2.5s:不管 PLC 调用卡在哪,本请求 2.5s 必返回
//(读结果 goroutine 随拨号超时自然结束,结果进带缓冲 channel 不会泄漏阻塞)。
if s.ctx.PLC != nil && !s.ctx.PLC.IsMock() {
logx.WithContext(ctx).Infof("[AGV][guard] 目标=%s 开始读取 PLC 在位传感器(硬切 2.5s)", target)
has, perr := s.plcQueryDockPalletHardCut(ctx, target, 2500*time.Millisecond)
if perr != nil {
logx.WithContext(ctx).Errorf("[AGV][guard] 目标=%s PLC 传感器读取失败,按定案放行派车: %v", target, perr)
s.ctx.EventLog.Write(ctx, "agv.plc_sensor_skip", "system", "", "agv_point", target,
"派车防撞校验未能读取 PLC 传感器(不可达或超时,已按定案放行派车),现场请目视确认接驳台无托盘:"+perr.Error(), nil)
} else if has {
logx.WithContext(ctx).Errorf("[AGV][guard] 目标=%s PLC 传感器检测到托盘,拒派", target)
return fmt.Errorf("目标接驳台 %s 传感器检测到托盘,存在碰撞风险,禁止派车(请先清空接驳台或人工核实传感器)", target)
} else {
logx.WithContext(ctx).Infof("[AGV][guard] 目标=%s PLC 传感器确认无托盘,放行", 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)
}
// plcHardCut 通用 PLC 读取硬切(2026-11-17):纯 WithTimeout 打断不了 plc/tcp.go
// readBytes 的互斥锁等待(先 s.mu.Lock() 再 ensure()→Connect(),PLC 断电时监控页轮询
// 持锁拨号可达 30s,mutex 不感知 ctx),必须用 goroutine + select 硬切:不管 PLC 调用
// 卡在哪,最多等 timeout 就返回。读结果 goroutine 随拨号超时自然结束,结果进带缓冲
// channel 不会泄漏阻塞。AGV 防撞、工位模板预检等所有同步 PLC 读都走这里,避免 503。
func plcHardCut[T any](ctx context.Context, timeout time.Duration, call func(context.Context) (T, error)) (T, error) {
var zero T
resCh := make(chan struct {
val T
err error
}, 1)
bgCtx, bgCancel := context.WithTimeout(context.Background(), timeout)
go func() {
v, e := call(bgCtx)
bgCancel()
resCh <- struct {
val T
err error
}{v, e}
}()
select {
case r := <-resCh:
return r.val, r.err
case <-time.After(timeout):
return zero, fmt.Errorf("PLC 读取超过 %s 未返回(连接被其他请求的拨号阻塞或 PLC 不可达),已硬切", timeout)
}
}
// plcQueryDockPalletHardCut 接驳台托盘传感器硬切读取(包装通用 plcHardCut)。
func (s *Service) plcQueryDockPalletHardCut(ctx context.Context, dockCode string, timeout time.Duration) (bool, error) {
return plcHardCut(ctx, timeout, func(c context.Context) (bool, error) {
return s.ctx.PLC.Get().QueryDockPallet(c, dockCode)
})
}
// 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 无真实传感器,跳过
}
// 2026-11-17 补:同样走硬切——PLC 断电时动作请求(送达/取货确认等)也会被拨号拖死
has, err := s.plcQueryDockPalletHardCut(ctx, dockCode, 2500*time.Millisecond)
if err != nil {
logx.WithContext(ctx).Infof("[AGV][ledger] 接驳台=%s 传感器↔台账校验跳过: %v", dockCode, err)
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 "无"
}