wangxinhui
2025-11-30 f2b85c65234e0dcdd3fcce4dafbe16933b7f1b48
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
using Autofac.Core;
using Microsoft.AspNetCore.Components.Routing;
using Newtonsoft.Json;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Math;
using Quartz;
using System;
using System.Collections.Generic;
using System.IdentityModel.Tokens.Jwt;
using System.Linq;
using System.Reflection.Metadata;
using System.Text;
using System.Threading.Tasks;
using WIDESEAWCS_Common;
using WIDESEAWCS_Common.Helper;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Communicator;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.Helper;
using WIDESEAWCS_IBasicInfoRepository;
using WIDESEAWCS_ITaskInfoRepository;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_QuartzJob;
using WIDESEAWCS_QuartzJob.ConveyorLine.Enum;
using WIDESEAWCS_QuartzJob.DTO;
using WIDESEAWCS_QuartzJob.Models;
using WIDESEAWCS_QuartzJob.Repository;
using WIDESEAWCS_QuartzJob.Service;
using WIDESEAWCS_Tasks.DBNames;
using ICacheService = WIDESEAWCS_Core.Caches.ICacheService;
 
namespace WIDESEAWCS_Tasks
{
    [DisallowConcurrentExecution]
    public class MDJob_CP : JobBase, IJob
    {
        private readonly ICacheService _cacheService;
        private readonly ITaskService _taskService;
        private readonly ITaskExecuteDetailService _taskExecuteDetailService;
        private readonly ITaskRepository _taskRepository;
        private readonly IStationMangerRepository _stationMangerRepository;
        private readonly IRouterRepository _routerRepository;
        private readonly IRouterService _routerService;
        private readonly IRouterExtension _routerExtension;
 
        public MDJob_CP(ICacheService cacheService, ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, ITaskRepository taskRepository, IStationMangerRepository stationMangerRepository, IRouterRepository routerRepository, IRouterService routerService, IRouterExtension routerExtension)
        {
            _cacheService = cacheService;
            _taskService = taskService;
            _taskExecuteDetailService = taskExecuteDetailService;
            _taskRepository = taskRepository;
            _stationMangerRepository = stationMangerRepository;
            _routerRepository = routerRepository;
            _routerService = routerService;
            _routerExtension = routerExtension;
        }
 
        public Task Execute(IJobExecutionContext context)
        {
            bool flag = context.JobDetail.JobDataMap.TryGetValue("JobParams", out object? value);
            if (flag && value != null)
            {
                OtherDevice device = (OtherDevice)value;
                List<Dt_StationManger> stationMangers = _stationMangerRepository.QueryData(x => x.CraneCode == device.DeviceCode);
                foreach (var item in stationMangers)
                {
                    //获取协议
                    DeviceProDTO? deviceProRead = device.DeviceProDTOs.Where(x => x.DeviceChildCode == item.CraneCode && x.DeviceProParamType == nameof(R_MDDB)).OrderBy(x => x.DeviceProOffset).FirstOrDefault();
                    DeviceProDTO? deviceProWrite = device.DeviceProDTOs.Where(x => x.DeviceChildCode == item.CraneCode && x.DeviceProParamType == nameof(W_MDDB)).OrderBy(x => x.DeviceProOffset).FirstOrDefault();
                    if (deviceProRead != null && deviceProWrite != null)
                    {
                        short Allow = device.GetValue<R_MDDB, short>(R_MDDB.R_MDAllow, item.CraneCode);
 
                        #region 读取工位状态
                        short R_MDStatus1 = device.GetValue<R_MDDB, short>(R_MDDB.R_MDStatus1, item.CraneCode);
                        short R_MDStatus2 = device.GetValue<R_MDDB, short>(R_MDDB.R_MDStatus2, item.CraneCode);
                        short R_MDStatus3 = device.GetValue<R_MDDB, short>(R_MDDB.R_MDStatus3, item.CraneCode);
                        short R_MDStatus4 = device.GetValue<R_MDDB, short>(R_MDDB.R_MDStatus4, item.CraneCode);
 
                        short ReceiveDoneState = device.GetValue<W_MDDB, short>(W_MDDB.W_MDReceiveDone, item.CraneCode);
                        #endregion
                        //码垛状态
                        short PackState = device.GetValue<R_MDDB, short>(GetPackStateEnum(item.CraneStationCode), item.CraneCode);
                        //码垛数量
                        short PackNum = device.GetValue<R_MDDB, short>(GetPackNumEnum(item.CraneStationCode), item.CraneCode);
                        if (R_MDStatus1 == 1 || R_MDStatus2 == 1 || R_MDStatus3 == 1 || R_MDStatus4 == 1)
                        {
                            Thread.Sleep(200);
                            if (ReceiveDoneState != 0)
                            {
                                device.Communicator.Write<short>(device.DeviceProDTOs.FirstOrDefault(x => x.DeviceProParamName == W_MDDB.W_MDReceiveDone.ToString()).DeviceProDataBlock, 0);
                                WriteInfo(item.CraneCode, $"{item.CraneCode}清除下发标识信号");
                            }
                            continue;
                        }
                        if (PackState == 2)
                        {
                            Thread.Sleep(200);
                            device.Communicator.Write<float>(device.DeviceProDTOs.FirstOrDefault(x => x.DeviceProParamName == GetPackSendEnum(item.CraneStationCode).ToString()).DeviceProDataBlock, 0);
                            WriteInfo(item.StationName, $"{item.StationName}清除工位结托信号");
                            continue;
                        }
                        device.Communicator.Write<short>(device.DeviceProDTOs.FirstOrDefault(x => x.DeviceProParamName == GetPackSendEnum(item.CraneStationCode).ToString()).DeviceProDataBlock, 2);
                        WriteInfo(item.StationName, $"{item.StationName}写入工位结托信号");
                        //获取当前任务
                        Dt_Task task = _taskRepository.QueryData(x => x.NextAddress == item.StationCode && _taskService.TaskInboundTypes.Contains(x.TaskType) && x.DeviceCode == device.DeviceCode).OrderBy(x => x.TaskNum).FirstOrDefault();
 
                        if (task != null)
                        {
                            //写入工位号
                            device.Communicator.Write<short>(device.DeviceProDTOs.FirstOrDefault(x => x.DeviceProParamName == W_MDDB.W_MDSendID.ToString()).DeviceProDataBlock, Convert.ToInt16(item.CraneStationCode));
                            //写入工位允许码垛
                            device.Communicator.Write<short>(device.DeviceProDTOs.FirstOrDefault(x => x.DeviceProParamName == GetPackSendEnum(item.CraneStationCode).ToString()).DeviceProDataBlock, 1);
 
                            #region 获取写入码垛X、Y、Z坐标
 
                            WriteInfo(item.StationName, $"码垛数量【{PackNum}】");
                            #endregion
 
                            device.Communicator.Write<float>(device.DeviceProDTOs.FirstOrDefault(x => x.DeviceProParamName == W_MDDB.W_MDA.ToString()).DeviceProDataBlock, 1);
                            //写入下发标识
                            device.Communicator.Write<short>(device.DeviceProDTOs.FirstOrDefault(x => x.DeviceProParamName == W_MDDB.W_MDReceiveDone.ToString()).DeviceProDataBlock, 3);
 
                            //更新任务信息
                            task.TaskState = TaskStatusEnum.Finish.ObjToInt();
                            //_taskRepository.UpdateData(task);
                            //_taskService.TaskCompleted(task.TaskNum);
                            Thread.Sleep(1000);
                            WriteInfo(item.StationName, $"任务号{task.TaskNum}码垛");
                            return Task.CompletedTask;
                        }
                    }
                    else
                    {
                        WriteError(item.StationName, $"未找到设备子编号{item.StationCode}的协议信息");
                    }
                }
            }
            return Task.CompletedTask;
        }
        /// <summary>
        /// 码垛数量
        /// </summary>
        public R_MDDB GetPackNumEnum(string StationCode)
        {
            switch (StationCode)
            {
                case "1":
                    return R_MDDB.R_MDQtys1;
                case "2":
                    return R_MDDB.R_MDQtys2;
                case "3":
                    return R_MDDB.R_MDQtys3;
                case "4":
                    return R_MDDB.R_MDQtys4;
                default:
                    throw new Exception("未定义工位");
            }
        }
        /// <summary>
        /// 码垛状态
        /// </summary>
        public R_MDDB GetPackStateEnum(string StationCode)
        {
            switch (StationCode)
            {
                case "1":
                    return R_MDDB.R_MDStatus1;
                case "2":
                    return R_MDDB.R_MDStatus2;
                case "3":
                    return R_MDDB.R_MDStatus3;
                case "4":
                    return R_MDDB.R_MDStatus4;
                default:
                    throw new Exception("未定义工位");
            }
        }
        /// <summary>
        /// 码垛工位
        /// </summary>
        public W_MDDB GetPackSendEnum(string StationCode)
        {
            switch (StationCode)
            {
                case "1":
                    return W_MDDB.W_MDSend1;
                case "2":
                    return W_MDDB.W_MDSend2;
                case "3":
                    return W_MDDB.W_MDSend3;
                case "4":
                    return W_MDDB.W_MDSend4;
                default:
                    throw new Exception("未定义工位");
            }
        }
    }
}