Files
bj_power/bj_power_mes/internal/logic/agv.go
T
SunYF 46fcb59079 feat: 退料闭环定稿(损耗台账/备料清单/退料AGV自动派车/剩余量参考)+ 工位托盘守卫
- MES 新增损耗台账 loss_ledger,差异确认损耗接口 ConfirmReceiveLoss(按工单归集)
- 备料清单 preparation:MES 按 日计划×工单×工位×物料 实时计算,WMS 只读展示 PreparationList
- 退料闭环:N5 工位托盘守卫(未完成禁止退料)、退料 AGV 自动派车(JBT21 空位判定 + 托盘回收链路)、退料参考剩余量接口(应剩余=实备-已耗-已退-已损)
- 新增 AGV 车辆状态表 agv_vehicle_state 及查询
- 整合接驳台/叫料池/库存锁既有闭环,清理 sql 目录注释生成脚本与 catalog,更新文档
2026-11-04 19:06:03 +08:00

931 lines
37 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/dock"
"bj_power_mes/ent/materialrequest"
"bj_power_mes/internal/agv"
"github.com/google/uuid"
)
// ============ AGV 调度(2026-10-14 由 WMS 迁至 MES 为唯一真源) ============
// MES 持有海康 RCS 客户端与 agv_tasks 表;仓库完成备料(CompleteCall)后由 MES 触发派车。
// WMS 仅作为 UI 代理(/api/internal/agv/*)转发到本逻辑。
// AgvSubmitRow 下发 AGV 的一行(与 WMS 端 agvSubmitRow 字段一致,便于透明代理)。
type AgvSubmitRow struct {
RequestNo string `json:"requestNo"`
MaterialCode string `json:"materialCode"`
MaterialName string `json:"materialName"`
Unit string `json:"unit"`
Qty float64 `json:"qty"`
TargetDock string `json:"targetDock"`
}
// AgvSubmitRequest 手动下发 AGV(WMS「下发AGV」页 / MES UI)。
type AgvSubmitRequest struct {
Rows []AgvSubmitRow `json:"rows"`
SourceDock string `json:"sourceDock"`
}
// 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"`
CreatedAt int64 `json:"createdAt"`
}
// SubmitAgv 手动下发 AGV:目标=AGV 点位编码(position_code),按点位聚合生成任务并调 RCS。
// 防撞强校验:接驳台点位有托盘 → 拒派;纯点位(无传感器)由前端二次确认后放行。
func (s *Service) SubmitAgv(ctx context.Context, req AgvSubmitRequest, operator string) (int, []string, error) {
if len(req.Rows) == 0 {
return 0, 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, errors.New("所选料行缺少目标点位(targetDock)")
}
// 解析点位:硬件映射 + 防撞强校验(接驳台点位有托盘拒派)
type resolved struct {
phys string // 送往 RCS 的物理目标(接驳台点位=dockCode;纯点位=position_code)
}
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
}
resolvedMap[target] = resolved{phys: d.DockCode}
} else {
resolvedMap[target] = resolved{phys: pt.PositionCode} // 纯点位
}
}
if len(unknown) > 0 {
return 0, unknown, fmt.Errorf("目标点位不存在:%s", strings.Join(unknown, "、"))
}
if len(collide) > 0 {
return 0, collide, fmt.Errorf("目标接驳台有托盘或已停用,存在碰撞/失效风险,禁止派车:%s(请在「产线管理」清空托盘或恢复启用后重试)", strings.Join(collide, "、"))
}
created := 0
failed := []string{}
for target, rows := range groups {
r, ok := resolvedMap[target]
if !ok {
failed = append(failed, target)
continue
}
taskNo := "AGV" + strings.ToUpper(uuid.NewString()[:10])
mats, _ := json.Marshal(rows)
t, err := s.ctx.EntClient.AgvTask.Create().
SetTaskNo(taskNo).
SetSourceDock(source).
SetTargetDock(r.phys).
SetMaterialsJSON(string(mats)).
SetStatus("PENDING").
SetKind("TRANSPORT").
SetBizType("CALL").
SetOperator(operator).
SetDispatchedAt(0).
SetArrivedAt(0).Save(ctx)
if err != nil {
failed = append(failed, target)
continue
}
if robCode, aerr := s.ctx.Agv.SubmitTask(ctx, taskNo, source, r.phys, ""); aerr != nil {
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).
SetHikTaskCode(robCode).SetStatus("1").
SetDispatchedAt(time.Now().Unix()).Exec(ctx)
}
s.ctx.EventLog.Write(ctx, "agv.dispatch", "", operator, "agv_task", taskNo,
"下发AGV搬运 "+source+"→"+r.phys, map[string]any{"rows": len(rows)})
created++
}
return created, failed, nil
}
// ListAgvPoints 列出 AGV 点位(enabledOnly=true 仅返回启用项,供派车下拉)。
func (s *Service) ListAgvPoints(ctx context.Context, enabledOnly bool) ([]AgvPointView, error) {
q := s.ctx.EntClient.AgvPoint.Query()
if enabledOnly {
q = q.Where(agvpoint.Enabled(true))
}
pts, err := q.Order(agvpoint.ByPositionCode()).All(ctx)
if err != nil {
return nil, err
}
docks, _ := s.ctx.EntClient.Dock.Query().All(ctx)
dockCodeByID := map[int]string{}
dockHasPallet := map[int]bool{}
for _, d := range docks {
dockCodeByID[d.ID] = d.DockCode
dockHasPallet[d.ID] = d.HasPallet
}
out := make([]AgvPointView, 0, len(pts))
for _, p := range pts {
v := AgvPointView{
ID: p.ID, PositionCode: p.PositionCode, Name: p.Name, IsDock: p.IsDock,
DockID: p.DockID, Enabled: p.Enabled, CreatedAt: p.CreatedAt.Unix(),
}
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
}
// LoadCallForDispatch 取叫料单用于派车(与 CompleteCall 同口径:仅 SHIPPED 状态可派车)。
func (s *Service) LoadCallForDispatch(ctx context.Context, requestNo string) (*ent.MaterialRequest, error) {
mr, err := s.ctx.EntClient.MaterialRequest.Query().
Where(materialrequest.RequestNo(requestNo)).Only(ctx)
if err != nil || mr == nil {
return nil, errors.New("叫料单不存在")
}
if mr.Status != "SHIPPED" {
return nil, errors.New("仅已发货(SHIPPED)的叫料单可派车")
}
return mr, nil
}
// 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("仅已发货(SHIPPED)的叫料单可派车(请先完成备料)")
}
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)
}
// DispatchAgvForCall 叫料派车(2026-11-03 定论修订:废除自动派车,改为库管人工触发):
// 由库管在 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"`
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,
AgvCode: t.AgvCode,
Operator: t.Operator,
DispatchedAt: t.DispatchedAt,
ArrivedAt: t.ArrivedAt,
Remark: t.Remark,
CreatedAt: t.CreatedAt,
}
}
// ListAgvVehicles 只读获取车辆状态(3.1.7 queryAgvStatus),供前端展示闲忙/充电/电量/位置。
// 纯只读:调度完全交给 RCS 自身,本系统不干预。Mock 模式返回示例车。
func (s *Service) ListAgvVehicles(ctx context.Context) ([]agv.AgvVehicle, error) {
if s.ctx.Agv == nil || s.ctx.Agv.Disable() {
// Mock:返回示例(避免前端在模拟模式下报错;真实模式由 RCS 提供)
return s.ctx.Agv.QueryAgvStatus(ctx)
}
return s.ctx.Agv.QueryAgvStatus(ctx)
}
// ListAgvTasks 查询 AGV 任务(分页;与 WMS Agv.vue 契约保持 {list,total,page,pageSize})。
func (s *Service) ListAgvTasks(ctx context.Context, status, targetDock string, page, size int) (map[string]any, error) {
query := s.ctx.EntClient.AgvTask.Query()
if status != "" {
query = query.Where(agvtask.Status(status))
}
if targetDock != "" {
query = query.Where(agvtask.TargetDock(targetDock))
}
total, err := query.Clone().Count(ctx)
if err != nil {
return nil, err
}
if size < 1 || size > 200 {
size = 20
}
rows, err := query.
Order(ent.Desc(agvtask.FieldCreatedAt)).
Offset((page - 1) * size).Limit(size).All(ctx)
if err != nil {
return nil, err
}
list := make([]AgvTaskView, 0, len(rows))
for _, t := range rows {
list = append(list, toAgvTaskView(t))
}
return map[string]any{
"list": list,
"total": total,
"page": page,
"pageSize": size,
}, nil
}
// RefreshAgvTasks 拉取海康 RCS 更新未终态任务状态(由「刷新状态」按钮 / RCS 回调事件触发,无独立定时器)。
// 同时驱动「传感器自动放行」:ARRIVED 任务的落点接驳台若被 PLC 传感器检测到托盘,则自动卸货放行。
func (s *Service) RefreshAgvTasks(ctx context.Context) (int, error) {
list, err := s.ctx.EntClient.AgvTask.Query().
Where(
agvtask.StatusIn("1", "2"),
agvtask.HikTaskCodeNEQ(""),
).All(ctx)
if err != nil {
return 0, err
}
changed := 0
for _, t := range list {
st, agvCode, qerr := s.ctx.Agv.QueryTask(ctx, t.HikTaskCode)
if qerr != nil {
continue
}
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": // 已结束(到位)
// 2026-11-03 三层机制:到位后视段类型分流——空车回充段(auto_end)直接结束;
// 其余段进 ARRIVED「到位待令」,必须人工「确认装车并送货/卸货完成并放行」才继续。
if t.AutoEnd {
upd.SetStatus("9").SetArrivedAt(time.Now().Unix())
} else {
upd.SetStatus("ARRIVED").SetArrivedAt(time.Now().Unix())
s.ctx.EventLog.Write(ctx, "agv.arrive", "", "", "agv_task", t.TaskNo,
"AGV已到位,等待人工确认 "+t.TargetDock, nil)
}
case "5": // 取消完成
upd.SetStatus("5")
default: // 1 已创建 / 2 执行中
upd.SetStatus(st)
}
if err := upd.Exec(ctx); err == nil {
changed++
}
}
// 2026-11-03 拍板(用户修正):接驳台有 PLC 传感器,AGV 送达后「按传感器变化定夺」自动放行——
// 仅由本刷新动作(手动刷新 / RCS 回调)触发,不新增定时器、不轮询。
// 当 ARRIVED 任务的「落点接驳台」传感器检测到托盘(货已卸到该接驳台),视为装卸完成 → 自动卸货放行。
// 传感器故障时由人工点「卸货完成并放行 / 人工强制放行」兜底(见前端按钮)。
if n, err := s.sensorReleaseIfReady(ctx); err == nil {
changed += n
}
return changed, nil
}
// sensorReleaseIfReady 对「到位待令(ARRIVED)且落点是产线接驳台」的任务,读取该接驳台 PLC 传感器:
// 若检测到托盘(货已卸到位)→ 自动卸货放行(ConfirmUnloadRelease:落点 hasPallet=true、生成空车回充段)。
// 仅事件触发(RefreshAgvTasks 被刷新/回调调用时),零轮询。
func (s *Service) sensorReleaseIfReady(ctx context.Context) (int, error) {
tasks, err := s.ctx.EntClient.AgvTask.Query().
Where(agvtask.StatusEQ("ARRIVED"), agvtask.KindIn("TRANSPORT", "FREE")).All(ctx)
if err != nil {
return 0, err
}
if s.ctx.PLC == nil || s.ctx.PLC.IsMock() {
return 0, nil // mock 模式无真实传感器,交由人工确认
}
released := 0
for _, t := range tasks {
if t.TargetDock == "" {
continue
}
d, derr := s.ctx.EntClient.Dock.Query().Where(dock.DockCodeEQ(t.TargetDock)).First(ctx)
if derr != nil || d == nil || d.DockType != "line" {
continue // 仅产线接驳台有托盘传感器
}
has, perr := s.ctx.PLC.Get().QueryDockPallet(ctx, t.TargetDock)
if perr != nil || !has {
continue // 传感器未检测到托盘:未完成装卸,等待
}
// 传感器确认货已到位 → 自动放行(不弹窗、不阻塞)
if rerr := s.ConfirmUnloadRelease(ctx, t.TaskNo, "sensor-auto"); rerr == nil {
released++
}
}
return released, 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.HikTaskCode != "" && (t.Status == "1" || t.Status == "2") {
if cerr := s.ctx.Agv.CancelTask(ctx, t.HikTaskCode, reason); cerr != nil {
return fmt.Errorf("RCS 取消失败: %w", cerr)
}
}
if err := s.ctx.EntClient.AgvTask.UpdateOneID(t.ID).
SetStatus("5").SetRemark(reason).Exec(ctx); err != nil {
return err
}
s.ctx.EventLog.Write(ctx, "agv.cancel", "", operator, "agv_task", t.TaskNo,
"取消AGV搬运 "+t.SourceDock+"→"+t.TargetDock, map[string]any{"reason": reason})
return nil
}
// RetryAgvTask 重试失败/卡住的 AGV 任务:沿用原 taskNo/source/target 重新向 RCS 下发。
// 仅允许对 FAILED 与未成功下发的 PENDING 任务重试;已结束(9/5)不可重试;目标接驳台有托盘拒派。
func (s *Service) RetryAgvTask(ctx context.Context, taskNo, operator string) error {
t, err := s.ctx.EntClient.AgvTask.Query().Where(agvtask.TaskNo(taskNo)).First(ctx)
if err != nil {
return errors.New("AGV 任务不存在")
}
if t.Status == "9" || t.Status == "5" {
return errors.New("任务已结束,无法重试")
}
// 防撞强校验:目标接驳台点位有托盘/已停用 → 拒派(与手动派车一致)
if t.TargetDock != "" {
if pt, perr := s.ctx.EntClient.AgvPoint.Query().Where(agvpoint.PositionCode(t.TargetDock)).Only(ctx); perr == nil && pt != nil && pt.IsDock && pt.DockID != nil {
if d, derr := s.ctx.EntClient.Dock.Get(ctx, *pt.DockID); derr == nil && d != nil {
if d.HasPallet {
return errors.New("目标接驳台有托盘,禁止重试派车")
}
if d.Status == "DISABLED" {
return errors.New("目标接驳台已停用,禁止重试派车(请先在「产线管理」恢复启用)")
}
}
}
}
robCode, aerr := s.ctx.Agv.SubmitTask(ctx, taskNo, t.SourceDock, t.TargetDock, "")
if aerr != nil {
s.ctx.EntClient.AgvTask.UpdateOneID(t.ID).
SetStatus("FAILED").SetRemark("RCS重试下发失败: " + aerr.Error()).Exec(ctx)
return fmt.Errorf("RCS 重试下发失败: %w", aerr)
}
s.ctx.EntClient.AgvTask.UpdateOneID(t.ID).
SetHikTaskCode(robCode).SetStatus("1").
SetDispatchedAt(time.Now().Unix()).SetRemark("").Exec(ctx)
s.ctx.EventLog.Write(ctx, "agv.retry", "", operator, "agv_task", taskNo,
"重试AGV搬运 "+t.SourceDock+"→"+t.TargetDock, nil)
return nil
}
// AgvMode 返回 AGV 对接模式(mock / 真实 RCS),供前端提示当前是否在模拟。
func (s *Service) AgvMode() map[string]any {
mock := s.ctx.Agv.Disable()
tip := ""
if mock {
tip = "当前为模拟模式(未接真实海康 RCS-Lite):查询任务状态会立即标记为已结束,便于离线联调。现场对接请在配置中关闭 EnableMock 并填写 RCS-Lite 地址(BaseURL,默认端口 8182)。"
} else {
tip = "已对接真实海康 RCS-Lite。"
}
return map[string]any{"mock": mock, "tip": tip}
}
// ApplyAgvCallback RCS-Lite SPI 回调(文档 2.2.1 任务执行通知):按 taskCode 匹配任务,按 method 更新状态。
// method: start 任务开始 / outbin 走出储位 / end 任务结束 / cancel 任务单取消。
// RCS 数字状态:1 已创建 / 2 执行中 / 5 取消完成 / 9 已结束。
// robotCode(文档 2.2.1 必填 AGV 编号)用于绑定任务与载货台账(2026-11-04 载货状态补做)。
func (s *Service) ApplyAgvCallback(ctx context.Context, taskCode, method, robotCode string) error {
if taskCode == "" {
return errors.New("缺少 taskCode")
}
t, err := s.ctx.EntClient.AgvTask.Query().
Where(agvtask.HikTaskCode(taskCode)).Only(ctx)
if err != nil || t == nil {
return nil // 未知任务号(如 MOCK 或不匹配)静默忽略
}
var status string
arrived := false
switch method {
case "end":
// 2026-11-03 三层机制:到位分流——空车回充段(auto_end)直接结束;其余进 ARRIVED 待人工确认
if t.AutoEnd {
status = "9"
} else {
status = "ARRIVED"
}
arrived = true
case "cancel":
status = "5"
case "start", "outbin", "":
status = "2"
default:
status = "2"
}
upd := s.ctx.EntClient.AgvTask.UpdateOneID(t.ID).SetStatus(status)
// 2026-11-04 载货台账绑定:回调携带 robotCode 时回写任务 agv_code
if robotCode != "" && robotCode != t.AgvCode {
upd.SetAgvCode(robotCode)
}
if arrived {
upd.SetArrivedAt(time.Now().Unix())
}
if err := upd.Exec(ctx); err != nil {
return err
}
if arrived && status == "ARRIVED" {
s.ctx.EventLog.Write(ctx, "agv.arrive", "", "", "agv_task", t.TaskNo,
"AGV已到位(回调),等待人工确认 "+t.TargetDock, map[string]any{"method": method})
}
return nil
}
// notifyDeliveredOnArrival AGV 到位 → 关联出库单回写「已送达」(2026-11-03 断头路补全:
// 出库单状态机「已出库/已送达」此前无写者)。任务关联叫料单 → 叫料单上回写的 WMS 出库单号
//(可多个逗号分隔)→ 通知 WMS 置已送达。best-effort:WMS 不可达只记日志,不阻断到位链路。
func (s *Service) notifyDeliveredOnArrival(ctx context.Context, t *ent.AgvTask) {
if t == nil || t.RelatedRequestNo == "" || s.ctx.Wms == nil {
return
}
mr, mErr := s.ctx.EntClient.MaterialRequest.Query().
Where(materialrequest.RequestNo(t.RelatedRequestNo)).First(ctx)
if mErr != nil || mr == nil || mr.OutboundNo == "" {
return
}
nos := []string{}
for _, p := range strings.Split(mr.OutboundNo, ",") {
if p = strings.TrimSpace(p); p != "" {
nos = append(nos, p)
}
}
if len(nos) == 0 {
return
}
if dErr := s.ctx.Wms.DeliveredOutbound(ctx, nos); dErr != nil {
fmt.Println("出库单回写已送达失败(可忽略):", dErr)
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
BizType string // CALL / PALLET / FREE
BizNo string
ChainNo string // 空=新建链(取本段 taskNo)
Source string // 空=空车单点 path(RCS 派最近空闲车)
Target string
Materials []AgvSubmitRow
Operator string
AutoEnd bool
}
// dispatchAgvSegment 创建一段任务并自动下发 RCS(业务触发统一走此口)。返回本段 taskNo。
func (s *Service) dispatchAgvSegment(ctx context.Context, in agvSegInput) (string, error) {
if in.Target == "" {
return "", fmt.Errorf("缺少目标点位")
}
// 2026-11-04 载货防撞硬拒(B3):AGV 载货=true 且 目标接驳台有托盘(台账/PLC 传感器)→ 拒派
if err := s.guardLoadedAgvVsTarget(ctx, in.Target); err != nil {
return "", err
}
taskNo := "AGV" + strings.ToUpper(uuid.NewString()[:10])
chain := in.ChainNo
if chain == "" {
chain = taskNo
}
mats, _ := json.Marshal(in.Materials)
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).
SetOperator(in.Operator).
SetDispatchedAt(0).SetArrivedAt(0).Save(ctx)
if err != nil {
return "", err
}
robCode, aerr := s.ctx.Agv.SubmitTask(ctx, taskNo, in.Source, in.Target, "")
if aerr != nil {
s.ctx.EntClient.AgvTask.UpdateOneID(t.ID).
SetStatus("FAILED").SetRemark("RCS下发失败: " + aerr.Error()).Exec(ctx)
return "", aerr
}
s.ctx.EntClient.AgvTask.UpdateOneID(t.ID).
SetHikTaskCode(robCode).SetStatus("1").
SetDispatchedAt(time.Now().Unix()).Exec(ctx)
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 为空且链上关联叫料单时默认取叫料单目标接驳台。
func (s *Service) ConfirmLoadAndGo(ctx context.Context, taskNo, nextDock, operator 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 == "" {
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)
// 本段结束
s.ctx.EntClient.AgvTask.UpdateOneID(t.ID).SetStatus("9").Exec(ctx)
_, derr := s.dispatchAgvSegment(ctx, agvSegInput{
Kind: "TRANSPORT", BizType: t.BizType, BizNo: t.BizNo, ChainNo: t.ChainNo,
Source: t.TargetDock, Target: nextDock,
Materials: decodeSegMaterials(t.MaterialsJSON), Operator: operator,
})
if derr != nil {
return fmt.Errorf("运输段下发失败: %w", derr)
}
s.ctx.EventLog.Write(ctx, "agv.load_confirm", operator, "", "agv_task", taskNo,
"确认装车并送货,运输段 "+t.TargetDock+"→"+nextDock, nil)
return nil
}
// ConfirmUnloadRelease 卸货完成并放行(ARRIVED + TRANSPORT/FREE):
// 卸货动作写库(卸货点 hasPallet=true);本段结束;自动生成空车回充段(免确认,到位自动结束)。
// 出库单「已送达」回写也移至此处(货真正卸下才算送达)。
func (s *Service) ConfirmUnloadRelease(ctx context.Context, taskNo, operator string) error {
t, err := s.loadArrivedTask(ctx, taskNo, "TRANSPORT", "FREE")
if err != nil {
return err
}
// 卸货动作写库:托盘上台
s.setDockPalletByCode(ctx, t.TargetDock, true, chainRefOf(t), chainRefOf(t))
// 2026-11-04 载货台账(B1):卸货确认 → 该车置「空车」
s.setAgvLoadedState(ctx, t.AgvCode, false, "AUTO_UNLOAD", operator)
s.ctx.EntClient.AgvTask.UpdateOneID(t.ID).SetStatus("9").Exec(ctx)
// 出库单回写已送达(CALL 链)
if t.BizType == "CALL" {
s.notifyDeliveredOnArrival(ctx, t)
}
// 空车回充段:业务自动触发免确认,到位自动结束
if _, derr := s.dispatchAgvSegment(ctx, agvSegInput{
Kind: "EMPTY_RETURN", BizType: t.BizType, BizNo: t.BizNo, ChainNo: t.ChainNo,
Source: t.TargetDock, Target: agvChargePoint, Operator: operator, AutoEnd: true,
}); derr != nil {
fmt.Println("空车回充段下发失败(可人工调度):", derr)
}
s.ctx.EventLog.Write(ctx, "agv.unload_confirm", operator, "", "agv_task", taskNo,
"卸货完成并放行,托盘落位 "+t.TargetDock+",空车自动回充", nil)
// 事件驱动收口:检查有无 CLOSING 班次可置 CLOSED
s.maybeCloseShifts(ctx)
return nil
}
// FinishFreeReturn 自由调度「结束回充电位」(ARRIVED + FREE):本段结束,空车回充自动下发。
func (s *Service) FinishFreeReturn(ctx context.Context, taskNo, operator string) error {
t, err := s.loadArrivedTask(ctx, taskNo, "FREE")
if err != nil {
return err
}
s.ctx.EntClient.AgvTask.UpdateOneID(t.ID).SetStatus("9").Exec(ctx)
if _, derr := s.dispatchAgvSegment(ctx, agvSegInput{
Kind: "EMPTY_RETURN", BizType: "FREE", BizNo: t.BizNo, ChainNo: t.ChainNo,
Source: t.TargetDock, Target: agvChargePoint, Operator: operator, AutoEnd: true,
}); derr != nil {
return fmt.Errorf("回充段下发失败: %w", derr)
}
s.ctx.EventLog.Write(ctx, "agv.free_finish", operator, "", "agv_task", taskNo,
"自由调度结束,AGV 回充电位", nil)
return nil
}
// FreeDispatch 人工自由调度单点段(第三层强制确认——前端弹「请确保路径畅通无杂物」后调用):
// 生成 FREE 段自动下发;AGV 到位停住进 ARRIVED,页面显示等待人工选下一步。
func (s *Service) FreeDispatch(ctx context.Context, source, target, operator string) (string, error) {
if target == "" {
return "", errors.New("请选择目标点位")
}
// 目标为接驳台时保持防撞强校验(有托盘/停用拒派)
if err := s.guardTransportTarget(ctx, target); err != nil {
return "", err
}
return s.dispatchAgvSegment(ctx, agvSegInput{
Kind: "FREE", BizType: "FREE", Source: source, Target: target, Operator: operator,
})
}
// DispatchPalletRecovery 托盘回收(WMS 托盘工作台触发,业务自动触发免弹窗):
// 空车前往指定工位接驳台(GO_LOAD,装货点=有托盘的接驳台)→ 到位待令 → 库管确认装车 →
// 运输段送回库房 JBT21 → 到位待令 → 确认卸货(空托盘上台)→ 空车自动回充。
// 2026-11-04 定稿(Q5):JBT21 无空位(有托盘/在途任务占用)不派车——拉回来的托盘没地方放,
// 前端按钮已禁用,此处后端兜底拒绝。
func (s *Service) DispatchPalletRecovery(ctx context.Context, dockCode, operator string) error {
d, err := s.ctx.EntClient.Dock.Query().Where(dock.DockCodeEQ(dockCode)).First(ctx)
if err != nil || d == nil {
return fmt.Errorf("接驳台 %s 不存在", dockCode)
}
if d.Status == "DISABLED" {
return fmt.Errorf("接驳台 %s 已停用", dockCode)
}
if !d.HasPallet {
return fmt.Errorf("接驳台 %s 台账无托盘,无需回收(请先现场核实)", dockCode)
}
// JBT21 空位校验(2026-11-04 定稿 Q5):无空位提示并拒绝
if free, reason := s.Jbt21Free(ctx); !free {
return fmt.Errorf("库房接驳台 %s 暂无空位:%s。请先卸走库房接驳台上的托盘后再派车", dockStoreCode, reason)
}
_, err = s.dispatchAgvSegment(ctx, agvSegInput{
Kind: "GO_LOAD", BizType: "PALLET", BizNo: dockCode,
Source: "", Target: dockCode, Operator: operator,
})
return err
}
// FindArrivedTaskNo 按 业务单据号+段类型 查「到位待令」任务号(WMS 装车确认只知道叫料单号)。
func (s *Service) FindArrivedTaskNo(ctx context.Context, bizNo, kind string) (string, error) {
t, err := s.ctx.EntClient.AgvTask.Query().
Where(agvtask.BizNo(bizNo), agvtask.Kind(kind), agvtask.StatusEQ("ARRIVED")).
Order(ent.Desc(agvtask.FieldCreatedAt)).First(ctx)
if err != nil || t == nil {
return "", fmt.Errorf("该叫料单暂无「到位待令」的 %s 段任务", kind)
}
return t.TaskNo, nil
}
// loadArrivedTask 校验任务存在、处于 ARRIVED 且段类型匹配。
func (s *Service) loadArrivedTask(ctx context.Context, taskNo string, kinds ...string) (*ent.AgvTask, error) {
t, err := s.ctx.EntClient.AgvTask.Query().Where(agvtask.TaskNo(taskNo)).First(ctx)
if err != nil || t == nil {
return nil, errors.New("AGV 任务不存在")
}
if t.Status != "ARRIVED" {
return nil, errors.New("任务不在「到位待令」状态,无法执行该确认动作")
}
okKind := false
for _, k := range kinds {
if t.Kind == k {
okKind = true
}
}
if !okKind {
return nil, fmt.Errorf("该动作不适用于段类型 %s", t.Kind)
}
return t, nil
}
// guardTransportTarget 运输/自由调度目标防撞:接驳台必须启用且无托盘。
func (s *Service) guardTransportTarget(ctx context.Context, target string) error {
pt, err := s.ctx.EntClient.AgvPoint.Query().Where(agvpoint.PositionCode(target)).Only(ctx)
if err != nil || pt == nil {
return fmt.Errorf("目标点位不存在:%s", target)
}
if !pt.Enabled {
return fmt.Errorf("目标点位 %s 已停用,禁止派车", target)
}
if pt.IsDock && pt.DockID != nil {
d, derr := s.ctx.EntClient.Dock.Get(ctx, *pt.DockID)
if derr != nil || d == nil {
return fmt.Errorf("目标接驳台不存在:%s", target)
}
if d.Status == "DISABLED" {
return fmt.Errorf("目标接驳台 %s 已停用,禁止派车", target)
}
if d.HasPallet {
return fmt.Errorf("目标接驳台 %s 已有托盘,禁止派车(防撞)", target)
}
}
return nil
}
// setDockPalletByCode 动作写库:接驳台托盘台账增减(事件驱动,无轮询)。
// 同时做传感器↔台账相互认证(软校验):不一致落预警,供现场核实。
func (s *Service) setDockPalletByCode(ctx context.Context, dockCode string, hasPallet bool, palletRef, chainRef string) {
if dockCode == "" || dockCode == agvChargePoint {
return
}
d, err := s.ctx.EntClient.Dock.Query().Where(dock.DockCodeEQ(dockCode)).First(ctx)
if err != nil || d == nil {
return // 非 dock 类点位(充电位/待命位等)不落台账
}
ref := palletRef
if !hasPallet {
ref = ""
}
if uerr := s.ctx.EntClient.Dock.UpdateOneID(d.ID).SetHasPallet(hasPallet).SetPalletRef(ref).Exec(ctx); uerr != nil {
fmt.Println("接驳台台账更新失败:", uerr)
return
}
s.ctx.EventLog.Write(ctx, "dock.pallet", "", "", "dock", dockCode,
fmt.Sprintf("接驳台台账更新:hasPallet=%v(动作写库)", hasPallet), nil)
// 传感器↔台账相互认证(动作时校验,best-effort)
s.checkSensorVsLedger(ctx, dockCode, hasPallet, chainRef)
}
// checkSensorVsLedger 传感器↔台账相互认证:读 PLC 接驳台托盘传感器与 DB 台账比对,
// 不一致落预警(软校验不阻断流程,由现场人工核实——禁止定时轮询,仅在动作时校验)。
func (s *Service) checkSensorVsLedger(ctx context.Context, dockCode string, expectHasPallet bool, ref string) {
if s.ctx.PLC == nil || s.ctx.PLC.IsMock() {
return // mock PLC 无真实传感器,跳过
}
has, err := s.ctx.PLC.Get().QueryDockPallet(ctx, dockCode)
if err != nil {
return // PLC 不可达不阻断
}
if has != expectHasPallet {
_ = s.CreateAlert(ctx, "dock_sensor_mismatch", "警告", ref,
"接驳台 "+dockCode+" 传感器与台账不符:传感器="+boolCn(has)+",台账="+boolCn(expectHasPallet)+",请现场核实")
}
}
// decodeSegMaterials 还原段任务物料清单(空安全)。
func decodeSegMaterials(raw string) []AgvSubmitRow {
if raw == "" {
return nil
}
var rows []AgvSubmitRow
_ = json.Unmarshal([]byte(raw), &rows)
return rows
}
// chainRefOf 链引用(托盘 palletRef 用)。
func chainRefOf(t *ent.AgvTask) string {
if t.ChainNo != "" {
return t.ChainNo
}
return t.TaskNo
}
// boolCn bool 转中文。
func boolCn(b bool) string {
if b {
return "有"
}
return "无"
}