- 移除实体: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/客户问题/案例/部署手册/问题记录
1816 lines
83 KiB
Go
1816 lines
83 KiB
Go
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 "无"
|
||
}
|