Files
bj_power/bj_power_mes/internal/logic/agv.go
T

517 lines
19 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"
"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 = "DOCK21"
}
// 目标字段复用语义为 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").
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
}
// DispatchAgvForCall 叫料完成备料后由 MES 自动派车(CompleteCall 调用):
// 以库房 DOCK21 为源点,目标=叫料单目标接驳台,单任务下发。
// 失败仅记日志(best-effort),不阻断叫料完成备料的响应。
func (s *Service) DispatchAgvForCall(ctx context.Context, mr *ent.MaterialRequest, operator string) error {
if mr == nil || !mr.NeedAgv || mr.TargetDock == "" {
return nil
}
// 目标接驳台停用禁派(2026-11-03 断头路补全):按派车失败口径落预警,由人工改派或恢复接驳台。
if d, derr := s.ctx.EntClient.Dock.Query().Where(dock.DockCodeEQ(mr.TargetDock)).First(ctx); derr == nil && d != nil && d.Status == "DISABLED" {
err := fmt.Errorf("目标接驳台 %s 已停用,自动派车拒绝(请恢复接驳台或人工配送)", mr.TargetDock)
if alertErr := s.CreateAlert(ctx, "agv_dispatch_fail", "警告", mr.RequestNo,
"叫料单 "+mr.RequestNo+" AGV 派车失败:"+err.Error()); alertErr != nil {
fmt.Println("AGV 派车失败落预警异常:", alertErr)
}
return err
}
source := "DOCK21"
taskNo := "AGV" + strings.ToUpper(uuid.NewString()[:10])
row := AgvSubmitRow{
RequestNo: mr.RequestNo,
MaterialCode: mr.MaterialCode,
MaterialName: mr.MaterialName,
Unit: mr.Unit,
Qty: mr.SentQty,
TargetDock: mr.TargetDock,
}
mats, _ := json.Marshal([]AgvSubmitRow{row})
t, err := s.ctx.EntClient.AgvTask.Create().
SetTaskNo(taskNo).
SetSourceDock(source).
SetTargetDock(mr.TargetDock).
SetMaterialsJSON(string(mats)).
SetRelatedRequestNo(mr.RequestNo).
SetStatus("PENDING").
SetOperator(operator).
SetDispatchedAt(0).SetArrivedAt(0).Save(ctx)
if err != nil {
return err
}
robCode, aerr := s.ctx.Agv.SubmitTask(ctx, taskNo, source, mr.TargetDock, "")
if aerr != nil {
s.ctx.EntClient.AgvTask.UpdateOneID(t.ID).
SetStatus("FAILED").SetRemark("RCS下发失败: " + aerr.Error()).Exec(ctx)
// 派车失败 → 预警中心报警(AGV 异常属告警域,不改叫料单七态状态机;操作工可感知=料未到)
if alertErr := s.CreateAlert(ctx, "agv_dispatch_fail", "警告", mr.RequestNo,
"叫料单 "+mr.RequestNo+" AGV 派车失败("+source+"→"+mr.TargetDock+"):"+aerr.Error()); alertErr != nil {
fmt.Println("AGV 派车失败落预警异常:", alertErr)
}
return aerr
}
s.ctx.EntClient.AgvTask.UpdateOneID(t.ID).
SetHikTaskCode(robCode).SetStatus("1").
SetDispatchedAt(time.Now().Unix()).Exec(ctx)
// 派车成功:回写 AGV 任务号到叫料单(agv_task_no,与 AGV 任务互查)
_ = s.ctx.EntClient.MaterialRequest.UpdateOneID(mr.ID).SetAgvTaskNo(taskNo).Exec(ctx)
s.ctx.EventLog.Write(ctx, "agv.dispatch", "", operator, "agv_task", taskNo,
"叫料完成备料自动派车 "+source+"→"+mr.TargetDock,
map[string]any{"requestNo": mr.RequestNo, "materialCode": mr.MaterialCode})
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"`
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,
Operator: t.Operator,
DispatchedAt: t.DispatchedAt,
ArrivedAt: t.ArrivedAt,
Remark: t.Remark,
CreatedAt: t.CreatedAt,
}
}
// 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 更新未终态任务状态(被手动刷新按钮 / 定时任务调用)。
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, qerr := s.ctx.Agv.QueryTask(ctx, t.HikTaskCode)
if qerr != nil {
continue
}
upd := s.ctx.EntClient.AgvTask.UpdateOneID(t.ID)
switch st {
case "9": // 已结束(到位)
upd.SetStatus("9").SetArrivedAt(time.Now().Unix())
s.ctx.EventLog.Write(ctx, "agv.arrive", "", "", "agv_task", t.TaskNo,
"AGV已到位 "+t.TargetDock, nil)
s.notifyDeliveredOnArrival(ctx, t)
case "5": // 取消完成
upd.SetStatus("5")
default: // 1 已创建 / 2 执行中
upd.SetStatus(st)
}
if err := upd.Exec(ctx); err == nil {
changed++
}
}
return changed, 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("任务已结束,无法取消")
}
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 已结束。
func (s *Service) ApplyAgvCallback(ctx context.Context, taskCode, method 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":
status = "9"
arrived = true
case "cancel":
status = "5"
case "start", "outbin", "":
status = "2"
default:
status = "2"
}
upd := s.ctx.EntClient.AgvTask.UpdateOneID(t.ID).SetStatus(status)
if arrived {
upd.SetArrivedAt(time.Now().Unix())
}
if err := upd.Exec(ctx); err != nil {
return err
}
if arrived {
s.ctx.EventLog.Write(ctx, "agv.arrive", "", "", "agv_task", t.TaskNo,
"AGV已到位(回调) "+t.TargetDock, map[string]any{"method": method})
s.notifyDeliveredOnArrival(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)
return
}
s.ctx.EventLog.Write(ctx, "outbound.delivered", "", "AGV", "agv_task", t.TaskNo,
"AGV到位,出库单已回写「已送达」:"+mr.OutboundNo, nil)
}